From 265413748d2bed31f6363116d5c2255ccb896a5d Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 21 Oct 2021 14:17:37 -0700
Subject: [PATCH 01/27] Make time more relevant and simplify fixed timestep

There can be only one!!!
---
 crates/bevy_core/src/lib.rs                 |  26 +-
 crates/bevy_core/src/time/fixed_timestep.rs | 322 ++++----------------
 crates/bevy_core/src/time/time.rs           | 233 ++++++++++----
 examples/2d/text2d.rs                       |   8 +-
 examples/3d/spawner.rs                      |  75 +++++
 examples/3d/update_gltf_scene.rs            |  12 +-
 examples/ecs/component_change_detection.rs  |   2 +-
 examples/ecs/fixed_timestep.rs              |  50 +--
 examples/ecs/iter_combinations.rs           | 112 +++----
 examples/ecs/state.rs                       |  67 ++--
 examples/game/alien_cake_addict.rs          |  11 +-
 examples/game/breakout.rs                   | 122 +++-----
 examples/shader/animate_shader.rs           | 318 ++++++-------------
 examples/ui/text.rs                         |   2 +-
 14 files changed, 598 insertions(+), 762 deletions(-)
 create mode 100644 examples/3d/spawner.rs

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index f943b281426cfc..10daf75022e312 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -1,21 +1,22 @@
-#![warn(missing_docs)]
-//! This crate provides core functionality for Bevy Engine.
-
+mod bytes;
 mod float_ord;
+mod label;
 mod name;
 mod task_pool_options;
 mod time;
 
-pub use bytemuck::{bytes_of, cast_slice, Pod, Zeroable};
+pub use bytes::*;
 pub use float_ord::*;
+pub use label::*;
 pub use name::*;
 pub use task_pool_options::DefaultTaskPoolOptions;
 pub use time::*;
 
 pub mod prelude {
-    //! The Bevy Core Prelude.
     #[doc(hidden)]
-    pub use crate::{DefaultTaskPoolOptions, Name, Time, Timer};
+    pub use crate::{
+        DefaultTaskPoolOptions, EntityLabels, FixedTimestep, Labels, Name, Time, Timer
+    };
 }
 
 use bevy_app::prelude::*;
@@ -31,11 +32,10 @@ use std::ops::Range;
 #[derive(Default)]
 pub struct CorePlugin;
 
-/// A `SystemLabel` enum for ordering systems relative to core Bevy systems.
 #[derive(Debug, PartialEq, Eq, Clone, Hash, SystemLabel)]
 pub enum CoreSystem {
-    /// Updates the elapsed time. Any system that interacts with [Time] component should run after
-    /// this.
+    /// Updates the elapsed time.
+    /// Any system interacting with the [`Time`] resource should run after this.
     Time,
 }
 
@@ -49,11 +49,13 @@ impl Plugin for CorePlugin {
             .create_default_pools(&mut app.world);
 
         app.init_resource::<Time>()
-            .init_resource::<FixedTimesteps>()
+            .init_resource::<TimeAccumulator>()
+            .init_resource::<EntityLabels>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
             .register_type::<Entity>()
             .register_type::<Name>()
+            .register_type::<Labels>()
             .register_type::<Range<f32>>()
             .register_type::<Timer>()
             // time system is added as an "exclusive system" to ensure it runs before other systems
@@ -61,7 +63,9 @@ impl Plugin for CorePlugin {
             .add_system_to_stage(
                 CoreStage::First,
                 time_system.exclusive_system().label(CoreSystem::Time),
-            );
+            )
+            .add_startup_system_to_stage(StartupStage::PostStartup, entity_labels_system)
+            .add_system_to_stage(CoreStage::PostUpdate, entity_labels_system);
 
         register_rust_types(app);
         register_math_types(app);
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index d4469ec9b87fec..59d480b65f12fd 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -1,301 +1,87 @@
-use crate::Time;
 use bevy_ecs::{
-    archetype::{Archetype, ArchetypeComponentId},
-    component::ComponentId,
-    query::Access,
     schedule::ShouldRun,
-    system::{IntoSystem, Res, ResMut, System},
-    world::World,
+    system::{Res, ResMut}
 };
-use bevy_utils::HashMap;
-use std::borrow::Cow;
-
-/// The internal state of each [`FixedTimestep`].
-#[derive(Debug)]
-pub struct FixedTimestepState {
-    step: f64,
-    accumulator: f64,
-}
-
-impl FixedTimestepState {
-    /// The amount of time each step takes.
-    pub fn step(&self) -> f64 {
-        self.step
-    }
-
-    /// The number of steps made in a second.
-    pub fn steps_per_second(&self) -> f64 {
-        1.0 / self.step
-    }
-
-    /// The amount of time (in seconds) left over from the last step.
-    pub fn accumulator(&self) -> f64 {
-        self.accumulator
-    }
+use bevy_utils::Duration;
 
-    /// The percentage of "step" stored inside the accumulator. Calculated as accumulator / step.
-    pub fn overstep_percentage(&self) -> f64 {
-        self.accumulator / self.step
-    }
-}
-
-/// A global resource that tracks the individual [`FixedTimestepState`]s
-/// for every labeled [`FixedTimestep`].
-#[derive(Default)]
-pub struct FixedTimesteps {
-    fixed_timesteps: HashMap<String, FixedTimestepState>,
-}
-
-impl FixedTimesteps {
-    /// Gets the [`FixedTimestepState`] for a given label.
-    pub fn get(&self, name: &str) -> Option<&FixedTimestepState> {
-        self.fixed_timesteps.get(name)
-    }
-}
+use crate::Time;
 
-/// A system run criteria that enables systems or stages to run at a fixed timestep between executions.
-///
-/// This does not guarentee that the time elapsed between executions is exactly the provided
-/// fixed timestep, but will guarentee 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>>,
+#[derive(Debug, Clone)]
+pub struct TimeAccumulator {
+    time: Duration,
+    steps: usize,
 }
 
-impl Default for FixedTimestep {
+impl Default for TimeAccumulator {
     fn default() -> Self {
-        Self {
-            state: LocalFixedTimestepState::default(),
-            internal_system: Box::new(IntoSystem::into_system(Self::prepare_system(
-                Default::default(),
-            ))),
+        Self { 
+            time: Duration::from_secs(0), 
+            steps: 0
         }
     }
 }
 
-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()
+impl TimeAccumulator {
+    pub fn new(time: Duration, steps: usize) -> Self {
+        Self { 
+            time, 
+            steps
         }
     }
 
-    /// 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()
-        }
+    /// The number of accrued steps.
+    #[inline]
+    pub fn steps(&self) -> usize {
+        self.steps
     }
 
-    /// 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
+    /// The amount of time accrued toward the next step as [`Duration`].
+    #[inline]
+    pub fn overstep(&self) -> Duration {
+        self.time
     }
 
-    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
-        }
+    /// The amount of time accrued toward the next step as [`f32`] % of timestep.
+    pub fn overstep_percentage(&self, timestep: Duration) -> f32 {
+        self.time.div_duration_f32(timestep)
     }
-}
 
-#[derive(Clone)]
-struct LocalFixedTimestepState {
-    label: Option<String>, // TODO: consider making this a TypedLabel
-    step: f64,
-    accumulator: f64,
-    looping: bool,
-}
-
-impl Default for LocalFixedTimestepState {
-    fn default() -> Self {
-        Self {
-            step: 1.0 / 60.0,
-            accumulator: 0.0,
-            label: None,
-            looping: false,
-        }
+    /// The amount of time accrued toward the next step as [`f64`] % of timestep.
+    pub fn overstep_percentage_f64(&self, timestep: Duration) -> f64 {
+        self.time.div_duration_f64(timestep)
     }
-}
-
-impl LocalFixedTimestepState {
-    fn update(&mut self, time: &Time) -> ShouldRun {
-        if !self.looping {
-            self.accumulator += time.delta_seconds_f64();
-        }
-
-        if self.accumulator >= self.step {
-            self.accumulator -= self.step;
-            self.looping = true;
-            ShouldRun::YesAndCheckAgain
-        } else {
-            self.looping = false;
-            ShouldRun::No
+    
+    /// Add to the stored time, then convert into as many steps as possible.
+    pub fn add_time(&mut self, time: Duration, timestep: Duration) {
+        self.time += time;
+        while self.time >= timestep {
+            self.time -= timestep;
+            self.steps += 1;
         }
     }
-}
 
-impl System for FixedTimestep {
-    type In = ();
-    type Out = ShouldRun;
-
-    fn name(&self) -> Cow<'static, str> {
-        Cow::Borrowed(std::any::type_name::<FixedTimestep>())
-    }
-
-    fn new_archetype(&mut self, archetype: &Archetype) {
-        self.internal_system.new_archetype(archetype);
-    }
-
-    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
-        self.internal_system.archetype_component_access()
-    }
-
-    fn component_access(&self) -> &Access<ComponentId> {
-        self.internal_system.component_access()
-    }
-
-    fn is_send(&self) -> bool {
-        self.internal_system.is_send()
+    /// Consume a stored step (if any).
+    pub fn sub_step(&mut self) -> Option<usize> {
+        self.steps.checked_sub(1)
     }
 
-    unsafe fn run_unsafe(&mut self, _input: (), world: &World) -> ShouldRun {
-        // SAFE: 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)
-    }
-
-    fn apply_buffers(&mut self, world: &mut World) {
-        self.internal_system.apply_buffers(world);
-    }
-
-    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,
-                },
-            );
-        }
-    }
-
-    fn check_change_tick(&mut self, change_tick: u32) {
-        self.internal_system.check_change_tick(change_tick);
+    pub fn reset(&mut self) {
+        self.time = 0.0;
+        self.steps = 0;
     }
 }
 
-#[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";
 
-    #[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();
+pub struct FixedTimestep;
 
-        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 advance_time(world: &mut World, instance: Instant, seconds: f32) {
-        world
-            .resource_mut::<Time>()
-            .update_with_instant(instance.add(Duration::from_secs_f32(seconds)));
-    }
-
-    fn get_accumulator_deciseconds(world: &World) -> f64 {
-        world
-            .resource::<FixedTimesteps>()
-            .get(LABEL)
-            .unwrap()
-            .accumulator
-            .mul(10.)
-            .round()
+impl FixedTimestep {
+    pub fn step (
+        mut accumulator: ResMut<TimeAccumulator>
+    ) -> ShouldRun {
+        if let Some(_) = accumulator.sub_step() {
+            ShouldRun::YesAndCheckAgain
+        } else {
+            ShouldRun::No
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index c47855e974a74e..c6c7b710a41dda 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -1,95 +1,183 @@
 use bevy_ecs::system::ResMut;
 use bevy_utils::{Duration, Instant};
 
-/// Tracks elapsed time since the last update and since the App has started
+use bevy_ecs::system::ResMut;
+use bevy_utils::{Duration, Instant};
+
+/// Tracks time elapsed since the previous update and total frame time since the app was started.
 #[derive(Debug, Clone)]
 pub struct Time {
     delta: Duration,
-    last_update: Option<Instant>,
-    delta_seconds_f64: f64,
     delta_seconds: f32,
-    seconds_since_startup: f64,
+    delta_seconds_f64: f64,
+    fixed_delta: Duration,
+    fixed_delta_seconds: f32,
+    fixed_delta_seconds_f64: f64,
+    speed_multiplier: f32,
     time_since_startup: Duration,
+    last_update: Option<Instant>,
     startup: Instant,
 }
 
 impl Default for Time {
-    fn default() -> Time {
-        Time {
+    fn default() -> Self {
+        // 60Hz is a popular number, but it can't be expressed as an exact float.
+        // Power-of-two frequencies (i.e. 32Hz, 64Hz, 128Hz) have better numeric stability.
+        let fixed_delta = Duration::from_secs_f32(1.0 / 64.0);
+        Self {
             delta: Duration::from_secs(0),
-            last_update: None,
-            startup: Instant::now(),
+            delta_seconds: 0.0,
             delta_seconds_f64: 0.0,
-            seconds_since_startup: 0.0,
+            fixed_delta,
+            fixed_delta_seconds: fixed_delta.as_secs_f32(),
+            fixed_delta_seconds_f64: fixed_delta.as_secs_f64(),
+            speed_multiplier: 1.0,
             time_since_startup: Duration::from_secs(0),
-            delta_seconds: 0.0,
+            last_update: None,
+            startup: Instant::now(),
         }
     }
 }
 
 impl Time {
-    /// Updates the internal time measurements.
     pub fn update(&mut self) {
-        self.update_with_instant(Instant::now());
+        let now = Instant::now();
+        self.update_with_instant(now);
     }
 
     pub(crate) 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();
             self.delta_seconds = self.delta.as_secs_f32();
+            self.delta_seconds_f64 = self.delta.as_secs_f64();
+            self.time_since_startup += self.delta.mul_f32(self.speed_multiplier);
         }
 
-        self.time_since_startup = instant - self.startup;
-        self.seconds_since_startup = self.time_since_startup.as_secs_f64();
         self.last_update = Some(instant);
     }
 
-    /// The delta between the current tick and last tick as a [`Duration`]
+    /// The delta between the current and last update, as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
         self.delta
     }
 
-    /// The delta between the current and last tick as [`f32`] seconds
+    /// The delta between the current and last 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
+    /// The delta between the current and last 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
+    /// The *virtual* delta between each fixed update step, as a [`Duration`].
+    /// Note that the true delta between fixed update steps varies.
     #[inline]
-    pub fn seconds_since_startup(&self) -> f64 {
-        self.seconds_since_startup
+    pub fn fixed_delta(&self) -> Duration {
+        self.fixed_delta
     }
 
-    /// The [`Instant`] the app was started
+    /// The *virtual* delta between each fixed update step, as [`f32`] seconds.
+    /// Note that the true delta between fixed update steps varies.
     #[inline]
-    pub fn startup(&self) -> Instant {
-        self.startup
+    pub fn fixed_delta_seconds(&self) -> f32 {
+        self.fixed_delta_seconds
+    }
+
+    /// The *virtual* delta between each fixed update step, as [`f64`] seconds.
+    /// Note that the true delta between fixed update steps varies.
+    #[inline]
+    pub fn fixed_delta_seconds_f64(&self) -> f64 {
+        self.fixed_delta_seconds_f64
+    }
+    
+    /// Changes fixed delta. Users are strongly cautioned against modifying 
+    /// the step rate this way, except during startup.
+    /// Prefer [`Time::set_speed_multiplier`] to ensure consistent simulation behavior.
+    pub fn set_steps_per_second(&mut self, steps: f32) {
+        self.fixed_delta = Duration::from_secs_f32(1.0 / steps);
+        self.fixed_delta_seconds = self.fixed_delta.as_secs_f32();
+        self.fixed_delta_seconds_f64 = self.fixed_delta.as_secs_f64();
+    }
+
+    /// The rate that app time advances relative to true clock time, as [`f32`].
+    /// Mainly used with the built-in fixed timestep.
+    #[inline]
+    pub fn speed_multiplier(&self) -> f32 {
+        self.speed_multiplier
     }
 
-    /// The ['Instant'] when [`Time::update`] was last called, if it exists
+    /// The rate that app time advances relative to true clock time, as [`f64`].
+    /// Mainly used with the built-in fixed timestep.
+    #[inline]
+    pub fn speed_multiplier_f64(&self) -> f64 {
+        self.speed_multiplier as f64
+    }
+
+    /// Set rate app time advances relative to true clock time.
+    #[inline]
+    pub fn set_speed_multiplier(&mut self, speed_multiplier: f32) {
+        self.speed_multiplier = speed_multiplier;
+    }
+
+    /// The ['Instant'] when [`Time::update`] was last called, if it exists.
     #[inline]
     pub fn last_update(&self) -> Option<Instant> {
         self.last_update
     }
 
-    /// The ['Duration'] from startup to the last update
+    /// The [`Instant`] the app was started.
+    #[inline]
+    pub fn startup(&self) -> Instant {
+        self.startup
+    }
+
+    /// The time since startup, as [`Duration`]. Affected by speed multiplier.
     #[inline]
     pub fn time_since_startup(&self) -> Duration {
         self.time_since_startup
     }
+
+    /// The time since startup, as [`f32`] seconds. Affected by speed multiplier.
+    #[inline]
+    pub fn seconds_since_startup(&self) -> f32 {
+        self.time_since_startup().as_secs_f32()
+    }
+
+    /// The time since startup, as [`f64`] seconds. Affected by speed multiplier.
+    #[inline]
+    pub fn seconds_since_startup_f64(&self) -> f64 {
+        self.time_since_startup().as_secs_f64()
+    }
+
+    /// The true clock time since startup, as [`Duration`]. May be different every call.
+    pub fn real_time_since_startup(&self) -> Duration {
+        Instant::now() - self.startup
+    }
+
+    /// The true clock time since startup, as [`f32`] seconds. May be different every call.
+    #[inline]
+    pub fn real_seconds_since_startup(&self) -> f32 {
+        self.real_time_since_startup().as_secs_f32()
+    }
+
+    /// The true clock time since startup, as [`f64`] seconds. May be different every call.
+    #[inline]
+    pub fn real_seconds_since_startup_f64(&self) -> f64 {
+        self.real_time_since_startup().as_secs_f64()
+    }
 }
 
-pub(crate) fn time_system(mut time: ResMut<Time>) {
+pub(crate) fn time_system(
+    mut time: ResMut<Time>,
+    mut accumulator: ResMut<TimeAccumulator>
+) {
     time.update();
+    accumulator.add_time(time.delta().mul_f64(time.speed_multiplier_f64()), time.fixed_delta());
 }
 
 #[cfg(test)]
@@ -102,20 +190,29 @@ mod tests {
     fn update_test() {
         let start_instant = Instant::now();
 
-        // Create a `Time` for testing
+        // Create a `Time` for testing.
         let mut time = Time {
             startup: start_instant,
             ..Default::default()
         };
 
-        // Ensure `time` was constructed correctly
+        // Ensure `time` was constructed correctly.
         assert_eq!(time.delta(), Duration::from_secs(0));
+        assert_eq!(time.delta_seconds(), 0.0);
+        assert_eq!(time.delta_seconds_f64(), 0.0);
+
+        // Fixed delta is fixed.
+        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
+        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
+        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+
+        // Sanity check.
         assert_eq!(time.last_update(), None);
         assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.delta_seconds_f64(), 0.0);
-        assert_eq!(time.seconds_since_startup(), 0.0);
+
+        // App advances 1:1 to with real time.
+        assert_eq!(time.speed_multiplier(), 1.0);
         assert_eq!(time.time_since_startup(), Duration::from_secs(0));
-        assert_eq!(time.delta_seconds(), 0.0);
 
         // Update `time` and check results
         let first_update_instant = Instant::now();
@@ -123,38 +220,68 @@ mod tests {
         time.update_with_instant(first_update_instant);
 
         assert_eq!(time.delta(), Duration::from_secs(0));
+        assert_eq!(time.delta_seconds(), 0.0);
+        assert_eq!(time.delta_seconds_f64(), 0.0);
+
+        // Fixed delta is still fixed.
+        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
+        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
+        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+
+        // Sanity check.
         assert_eq!(time.last_update(), Some(first_update_instant));
         assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.delta_seconds_f64(), 0.0);
-        assert_eq!(
-            time.seconds_since_startup(),
-            (first_update_instant - start_instant).as_secs_f64()
-        );
-        assert_eq!(
-            time.time_since_startup(),
-            (first_update_instant - start_instant)
-        );
-        assert_eq!(time.delta_seconds, 0.0);
+
+        // App advances 1:1 to with real time.
+        assert_eq!(time.speed_multiplier(), 1.0);
+        assert_eq!(time.time_since_startup(), first_update_instant - start_instant);
 
         // Update `time` again and check results
         let second_update_instant = Instant::now();
 
         time.update_with_instant(second_update_instant);
 
+        // At this point its safe to use time.delta().
         assert_eq!(time.delta(), second_update_instant - first_update_instant);
+        assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
+        assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
+
+        // Fixed delta is STILL fixed.
+        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
+        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
+        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+
+        // Sanity check.
         assert_eq!(time.last_update(), Some(second_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.seconds_since_startup(),
-            (second_update_instant - start_instant).as_secs_f64()
-        );
-        assert_eq!(
-            time.time_since_startup(),
-            (second_update_instant - start_instant)
-        );
+
+        // App advances 1:1 to with real time.
+        assert_eq!(time.speed_multiplier(), 1.0);
+        assert_eq!(time.time_since_startup(), second_update_instant - start_instant);
+
+        // Make app time advance at 2x the rate of real world time.
+        time.set_speed_multiplier(2.0);
+        
+        // Update `time` again 1 second later.
+        let third_update_instant = second_update_instant + Duration::from_secs(1);
+
+        time.update_with_instant(third_update_instant);
+
+        assert_eq!(time.delta(), third_update_instant - second_update_instant);
         assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
+        assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
+
+        // Fixed delta is still fixed.
+        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
+        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
+        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+
+        // Sanity check.
+        assert_eq!(time.last_update(), Some(third_update_instant));
+        assert_eq!(time.startup(), start_instant);
+
+        // App is advancing at 2x speed, so app time should have advanced by 2 seconds.
+        assert_eq!(time.speed_multiplier(), 2.0);
+        assert_eq!(time.time_since_startup(), second_update_instant - start_instant + Duration::from_secs(2));
     }
 }
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index 08c3dc8842a235..e3d607d51d5781 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -58,8 +58,8 @@ fn animate_translation(
     mut query: Query<&mut Transform, (With<Text>, With<AnimateTranslation>)>,
 ) {
     for mut transform in query.iter_mut() {
-        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.seconds_since_startup().sin() - 400.0;
+        transform.translation.y = 100.0 * time.seconds_since_startup().cos();
     }
 }
 
@@ -68,7 +68,7 @@ fn animate_rotation(
     mut query: Query<&mut Transform, (With<Text>, With<AnimateRotation>)>,
 ) {
     for mut transform in query.iter_mut() {
-        transform.rotation = Quat::from_rotation_z(time.seconds_since_startup().cos() as f32);
+        transform.rotation = Quat::from_rotation_z(time.seconds_since_startup().cos());
     }
 }
 
@@ -80,6 +80,6 @@ fn animate_scale(
     // rendered quad, resulting in a pixellated look.
     for mut transform in query.iter_mut() {
         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.seconds_since_startup().sin() + 1.1) * 2.0);
     }
 }
diff --git a/examples/3d/spawner.rs b/examples/3d/spawner.rs
new file mode 100644
index 00000000000000..9f54fceb4c504d
--- /dev/null
+++ b/examples/3d/spawner.rs
@@ -0,0 +1,75 @@
+use bevy::{
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    prelude::*,
+};
+use rand::{rngs::StdRng, Rng, SeedableRng};
+
+/// This example spawns a large number of cubes, each with its own changing position and material
+/// This is intended to be a stress test of bevy's ability to render many objects with different
+/// properties For the best results, run it in release mode:
+/// ```bash
+/// cargo run --example spawner --release
+/// ```
+/// NOTE: Bevy still has a number of optimizations to do in this area. Expect the
+/// performance here to go way up in the future
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_startup_system(setup)
+        .add_system(move_cubes)
+        .run();
+}
+
+fn move_cubes(
+    time: Res<Time>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut query: Query<(&mut Transform, &Handle<StandardMaterial>)>,
+) {
+    for (mut transform, material_handle) in query.iter_mut() {
+        let material = materials.get_mut(material_handle).unwrap();
+        transform.translation += Vec3::new(1.0, 0.0, 0.0) * time.delta_seconds();
+        material.base_color =
+            Color::BLUE * Vec3::splat((3.0 * time.seconds_since_startup()).sin());
+    }
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // light
+    commands.spawn_bundle(PointLightBundle {
+        transform: Transform::from_xyz(4.0, -4.0, 5.0),
+        ..Default::default()
+    });
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(0.0, 15.0, 150.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+
+    let mut rng = StdRng::from_entropy();
+    let cube_handle = meshes.add(Mesh::from(shape::Cube { size: 1.0 }));
+    for _ in 0..10000 {
+        commands.spawn_bundle(PbrBundle {
+            mesh: cube_handle.clone(),
+            material: materials.add(StandardMaterial {
+                base_color: Color::rgb(
+                    rng.gen_range(0.0..1.0),
+                    rng.gen_range(0.0..1.0),
+                    rng.gen_range(0.0..1.0),
+                ),
+                ..Default::default()
+            }),
+            transform: Transform::from_xyz(
+                rng.gen_range(-50.0..50.0),
+                rng.gen_range(-50.0..50.0),
+                0.0,
+            ),
+            ..Default::default()
+        });
+    }
+}
diff --git a/examples/3d/update_gltf_scene.rs b/examples/3d/update_gltf_scene.rs
index db06d79fd3fe5f..da21f425e89c34 100644
--- a/examples/3d/update_gltf_scene.rs
+++ b/examples/3d/update_gltf_scene.rs
@@ -76,15 +76,15 @@ fn move_scene_entities(
     time: Res<Time>,
     mut scene_entities: Query<&mut Transform, With<EntityInMyScene>>,
 ) {
-    let mut direction = 1.;
-    let mut scale = 1.;
+    let mut direction = 1.0;
+    let mut scale = 1.0;
     for mut transform in scene_entities.iter_mut() {
         transform.translation = Vec3::new(
-            scale * direction * time.seconds_since_startup().sin() as f32 / 20.,
-            0.,
-            time.seconds_since_startup().cos() as f32 / 20.,
+            scale * direction * time.seconds_since_startup().sin() / 20.0,
+            0.0,
+            time.seconds_since_startup().cos() / 20.0,
         );
-        direction *= -1.;
+        direction *= -1.0;
         scale += 0.5;
     }
 }
diff --git a/examples/ecs/component_change_detection.rs b/examples/ecs/component_change_detection.rs
index 01473c7749bc07..9ca065cd61a186 100644
--- a/examples/ecs/component_change_detection.rs
+++ b/examples/ecs/component_change_detection.rs
@@ -13,7 +13,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 f89d3046689ee9..136ba2d856283a 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -1,50 +1,50 @@
 use bevy::{
-    core::{FixedTimestep, FixedTimesteps},
+    core::{FixedTimestep, TimeAccumulator},
     prelude::*,
 };
 
-const LABEL: &str = "my_fixed_timestep";
-
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 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(set_fixed_timestep)
+        // This system will run once every update.
         .add_system(frame_update)
-        // add a new stage that runs twice a second
+        // This stage will run ten times a 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);
-    *last_time = time.seconds_since_startup();
+fn set_fixed_timestep(
+    mut time: ResMut<Time>,
+) {
+    time.set_steps_per_second(10);
 }
 
-fn fixed_update(mut last_time: Local<f64>, time: Res<Time>, fixed_timesteps: Res<FixedTimesteps>) {
-    info!(
-        "fixed_update: {}",
-        time.seconds_since_startup() - *last_time,
-    );
-
-    let fixed_timestep = fixed_timesteps.get(LABEL).unwrap();
-    info!(
-        "  overstep_percentage: {}",
-        fixed_timestep.overstep_percentage()
-    );
+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<f32>,
+    time: Res<Time>,
+    accumulator: Res<TimeAccumulator>,
+) {
+    info!("time since last fixed_update: {}\n", time.seconds_since_startup() - *last_time);
+    info!("fixed timestep: {}\n", time.fixed_delta_seconds());
+    info!("time accrued toward fixed_update: {}\n", accumulator.time());
+    info!("time accrued toward fixed_update (% of time.fixed_delta): {}", accumulator.overstep_percentage());
     *last_time = time.seconds_since_startup();
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index 396ee14e38d7ae..2d137e0b7722af 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -1,34 +1,34 @@
-use bevy::{core::FixedTimestep, pbr::AmbientLight, prelude::*, render::camera::Camera};
+use bevy::{core::FixedTimestep, prelude::*};
 use rand::{thread_rng, Rng};
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 struct FixedUpdateStage;
 
-const DELTA_TIME: f64 = 0.01;
-
 fn main() {
     App::new()
-        .insert_resource(Msaa { samples: 4 })
-        .add_plugins(DefaultPlugins)
-        .insert_resource(AmbientLight {
-            brightness: 0.03,
-            ..Default::default()
-        })
-        .add_startup_system(generate_bodies)
-        .add_stage_after(
-            CoreStage::Update,
-            FixedUpdateStage,
-            SystemStage::parallel()
-                .with_run_criteria(FixedTimestep::step(DELTA_TIME))
-                .with_system(interact_bodies)
-                .with_system(integrate),
-        )
-        .add_system(look_at_star)
-        .insert_resource(ClearColor(Color::BLACK))
-        .run();
+    .insert_resource(Msaa { samples: 4 })
+    .add_plugins(DefaultPlugins)
+    .add_startup_system(set_fixed_timestep)
+    .add_startup_system(generate_bodies)
+    .add_stage_after(
+        CoreStage::Update,
+        FixedUpdateStage,
+        SystemStage::parallel()
+        .with_run_criteria(FixedTimestep::step)
+        .with_system(interact_bodies)
+        .with_system(integrate),
+    )
+    .run();
+}
+
+fn set_fixed_timestep(
+    mut time: ResMut<Time>,
+) {
+    time.set_steps_per_second(100);
 }
 
 const GRAVITY_CONSTANT: f32 = 0.001;
+const SOFTENING: f32 = 0.01;
 const NUM_BODIES: usize = 100;
 
 #[derive(Component, Default)]
@@ -37,8 +37,6 @@ struct Mass(f32);
 struct Acceleration(Vec3);
 #[derive(Component, Default)]
 struct LastPos(Vec3);
-#[derive(Component)]
-struct Star;
 
 #[derive(Bundle, Default)]
 struct BodyBundle {
@@ -51,6 +49,7 @@ struct BodyBundle {
 
 fn generate_bodies(
     mut commands: Commands,
+    time: Res<Time>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
@@ -59,13 +58,14 @@ fn generate_bodies(
         subdivisions: 3,
     }));
 
+    let pos_range = 1.0..15.0;
     let color_range = 0.5..1.0;
     let vel_range = -0.5..0.5;
 
     let mut rng = thread_rng();
     for _ in 0..NUM_BODIES {
-        let radius: f32 = rng.gen_range(0.1..0.7);
-        let mass_value = radius.powi(3) * 10.;
+        let mass_value_cube_root: f32 = rng.gen_range(0.5..4.0);
+        let mass_value: f32 = mass_value_cube_root * mass_value_cube_root * mass_value_cube_root;
 
         let position = Vec3::new(
             rng.gen_range(-1.0..1.0),
@@ -73,19 +73,18 @@ fn generate_bodies(
             rng.gen_range(-1.0..1.0),
         )
         .normalize()
-            * rng.gen_range(0.2f32..1.0).powf(1. / 3.)
-            * 15.;
+            * rng.gen_range(pos_range.clone());
 
         commands.spawn_bundle(BodyBundle {
             pbr: PbrBundle {
                 transform: Transform {
                     translation: position,
-                    scale: Vec3::splat(radius),
+                    scale: Vec3::splat(mass_value_cube_root * 0.1),
                     ..Default::default()
                 },
                 mesh: mesh.clone(),
                 material: materials.add(
-                    Color::rgb(
+                    Color::rgb_linear(
                         rng.gen_range(color_range.clone()),
                         rng.gen_range(color_range.clone()),
                         rng.gen_range(color_range.clone()),
@@ -102,46 +101,35 @@ 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,
+                    ) * time.fixed_delta_seconds(),
             ),
         });
     }
 
     // add bigger "star" body in the center
-    let star_radius = 1.;
     commands
         .spawn_bundle(BodyBundle {
             pbr: PbrBundle {
-                transform: Transform::from_scale(Vec3::splat(star_radius)),
+                transform: Transform {
+                    scale: Vec3::splat(0.5),
+                    ..Default::default()
+                },
                 mesh: meshes.add(Mesh::from(shape::Icosphere {
                     radius: 1.0,
                     subdivisions: 5,
                 })),
-                material: materials.add(StandardMaterial {
-                    base_color: Color::ORANGE_RED,
-                    emissive: (Color::ORANGE_RED * 2.),
-                    ..Default::default()
-                }),
+                material: materials.add((Color::ORANGE_RED * 10.0).into()),
                 ..Default::default()
             },
-            mass: Mass(500.0),
+            mass: Mass(1000.0),
             ..Default::default()
         })
-        .insert(Star)
-        .with_children(|p| {
-            p.spawn_bundle(PointLightBundle {
-                point_light: PointLight {
-                    color: Color::WHITE,
-                    intensity: 400.0,
-                    range: 100.0,
-                    radius: star_radius,
-                    ..Default::default()
-                },
-                ..Default::default()
-            });
+        .insert(PointLight {
+            color: Color::ORANGE_RED,
+            ..Default::default()
         });
     commands.spawn_bundle(PerspectiveCameraBundle {
-        transform: Transform::from_xyz(0.0, 10.5, -30.0).looking_at(Vec3::ZERO, Vec3::Y),
+        transform: Transform::from_xyz(0.0, 10.5, -20.0).looking_at(Vec3::ZERO, Vec3::Y),
         ..Default::default()
     });
 }
@@ -154,15 +142,18 @@ fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)
         let delta = transform2.translation - transform1.translation;
         let distance_sq: f32 = delta.length_squared();
 
-        let f = GRAVITY_CONSTANT / distance_sq;
+        let f = GRAVITY_CONSTANT / (distance_sq * (distance_sq + SOFTENING).sqrt());
         let force_unit_mass = delta * f;
         acc1.0 += force_unit_mass * *m2;
         acc2.0 -= force_unit_mass * *m1;
     }
 }
 
-fn integrate(mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>) {
-    let dt_sq = (DELTA_TIME * DELTA_TIME) as f32;
+fn integrate(
+    time: Res<Time>,
+    mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>
+) {
+    let dt_sq = time.fixed_delta_seconds() * time.fixed_delta_seconds();
     for (mut acceleration, mut transform, mut last_pos) in query.iter_mut() {
         // verlet integration
         // x(t+dt) = 2x(t) - x(t-dt) + a(t)dt^2 + O(dt^4)
@@ -174,16 +165,3 @@ fn integrate(mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>
         transform.translation = new_pos;
     }
 }
-
-fn look_at_star(
-    mut camera: Query<&mut Transform, (With<Camera>, Without<Star>)>,
-    star: Query<&Transform, With<Star>>,
-) {
-    let mut camera = camera.single_mut();
-    let star = star.single();
-    let new_rotation = camera
-        .looking_at(star.translation, Vec3::Y)
-        .rotation
-        .lerp(camera.rotation, 0.1);
-    camera.rotation = new_rotation;
-}
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index 618b64c975c027..3a712c328040e4 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -1,10 +1,11 @@
 use bevy::prelude::*;
 
-/// This example illustrates how to use [`States`] to control transitioning from a `Menu` state to
-/// an `InGame` state.
+/// This example illustrates how to use States to control transitioning from a Menu state to an
+/// InGame state.
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
+        .init_resource::<ButtonMaterials>()
         .add_state(AppState::Menu)
         .add_system_set(SystemSet::on_enter(AppState::Menu).with_system(setup_menu))
         .add_system_set(SystemSet::on_update(AppState::Menu).with_system(menu))
@@ -28,11 +29,11 @@ struct MenuData {
     button_entity: Entity,
 }
 
-const NORMAL_BUTTON: Color = Color::rgb(0.15, 0.15, 0.15);
-const HOVERED_BUTTON: Color = Color::rgb(0.25, 0.25, 0.25);
-const PRESSED_BUTTON: Color = Color::rgb(0.35, 0.75, 0.35);
-
-fn setup_menu(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup_menu(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    button_materials: Res<ButtonMaterials>,
+) {
     // ui camera
     commands.spawn_bundle(UiCameraBundle::default());
     let button_entity = commands
@@ -47,7 +48,7 @@ fn setup_menu(mut commands: Commands, asset_server: Res<AssetServer>) {
                 align_items: AlignItems::Center,
                 ..Default::default()
             },
-            color: NORMAL_BUTTON.into(),
+            material: button_materials.normal.clone(),
             ..Default::default()
         })
         .with_children(|parent| {
@@ -70,22 +71,23 @@ fn setup_menu(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 fn menu(
     mut state: ResMut<State<AppState>>,
+    button_materials: Res<ButtonMaterials>,
     mut interaction_query: Query<
-        (&Interaction, &mut UiColor),
+        (&Interaction, &mut Handle<ColorMaterial>),
         (Changed<Interaction>, With<Button>),
     >,
 ) {
-    for (interaction, mut color) in interaction_query.iter_mut() {
+    for (interaction, mut material) in interaction_query.iter_mut() {
         match *interaction {
             Interaction::Clicked => {
-                *color = PRESSED_BUTTON.into();
+                *material = button_materials.pressed.clone();
                 state.set(AppState::InGame).unwrap();
             }
             Interaction::Hovered => {
-                *color = HOVERED_BUTTON.into();
+                *material = button_materials.hovered.clone();
             }
             Interaction::None => {
-                *color = NORMAL_BUTTON.into();
+                *material = button_materials.normal.clone();
             }
         }
     }
@@ -95,10 +97,15 @@ fn cleanup_menu(mut commands: Commands, menu_data: Res<MenuData>) {
     commands.entity(menu_data.button_entity).despawn_recursive();
 }
 
-fn setup_game(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup_game(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let texture_handle = asset_server.load("branding/icon.png");
     commands.spawn_bundle(OrthographicCameraBundle::new_2d());
     commands.spawn_bundle(SpriteBundle {
-        texture: asset_server.load("branding/icon.png"),
+        material: materials.add(texture_handle.into()),
         ..Default::default()
     });
 }
@@ -130,10 +137,32 @@ fn movement(
     }
 }
 
-fn change_color(time: Res<Time>, mut query: Query<&mut Sprite>) {
-    for mut sprite in query.iter_mut() {
-        sprite
+fn change_color(
+    time: Res<Time>,
+    mut assets: ResMut<Assets<ColorMaterial>>,
+    query: Query<&Handle<ColorMaterial>, With<Sprite>>,
+) {
+    for handle in query.iter() {
+        let material = assets.get_mut(handle).unwrap();
+        material
             .color
-            .set_b((time.seconds_since_startup() * 0.5).sin() as f32 + 2.0);
+            .set_b((time.seconds_since_startup() * 5.0).sin() + 2.0);
+    }
+}
+
+struct ButtonMaterials {
+    normal: Handle<ColorMaterial>,
+    hovered: Handle<ColorMaterial>,
+    pressed: Handle<ColorMaterial>,
+}
+
+impl FromWorld for ButtonMaterials {
+    fn from_world(world: &mut World) -> Self {
+        let mut materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
+        ButtonMaterials {
+            normal: materials.add(Color::rgb(0.15, 0.15, 0.15).into()),
+            hovered: materials.add(Color::rgb(0.25, 0.25, 0.25).into()),
+            pressed: materials.add(Color::rgb(0.35, 0.75, 0.35).into()),
+        }
     }
 }
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index db127bebd31f52..9c30a7f743b132 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -15,6 +15,7 @@ fn main() {
         .init_resource::<Game>()
         .add_plugins(DefaultPlugins)
         .add_state(GameState::Playing)
+        .add_startup_system(set_fixed_timestep)
         .add_startup_system(setup_cameras)
         .add_system_set(SystemSet::on_enter(GameState::Playing).with_system(setup))
         .add_system_set(
@@ -30,7 +31,7 @@ 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(FixedTimestep::step)
                 .with_system(spawn_bonus),
         )
         .add_system(bevy::input::system::exit_on_esc_system)
@@ -68,6 +69,12 @@ struct Game {
     camera_is_focus: Vec3,
 }
 
+fn set_fixed_timestep(
+    mut time: ResMut<Time>,
+) {
+    time.set_steps_per_second(1 / 5.0);
+}
+
 const BOARD_SIZE_I: usize = 14;
 const BOARD_SIZE_J: usize = 21;
 
@@ -357,7 +364,7 @@ fn rotate_bonus(game: Res<Game>, time: Res<Time>, mut transforms: Query<&mut Tra
         if let Ok(mut cake_transform) = transforms.get_mut(entity) {
             cake_transform.rotate(Quat::from_rotation_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(),
+                1.0 + (game.score as f32 / 10.0 * time.seconds_since_startup().sin()).abs(),
             );
         }
     }
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 66246feecc6204..ebfc7de2dcc5b3 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -1,11 +1,11 @@
 use bevy::{
     core::FixedTimestep,
     prelude::*,
+    render::pass::ClearColor,
     sprite::collide_aabb::{collide, Collision},
 };
 
 /// An implementation of the classic game "Breakout"
-const TIME_STEP: f32 = 1.0 / 60.0;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
@@ -14,7 +14,7 @@ fn main() {
         .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(paddle_movement_system)
                 .with_system(ball_collision_system)
                 .with_system(ball_movement_system),
@@ -45,7 +45,15 @@ struct Scoreboard {
     score: usize,
 }
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup(
+    mut commands: Commands,
+    mut time: ResMut<Time>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    asset_server: Res<AssetServer>,
+) {
+    // Set timestep
+    time.set_steps_per_second(60.0);
+
     // Add the game's entities to our world
 
     // cameras
@@ -54,15 +62,9 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     // paddle
     commands
         .spawn_bundle(SpriteBundle {
-            transform: Transform {
-                translation: Vec3::new(0.0, -215.0, 0.0),
-                scale: Vec3::new(120.0, 30.0, 0.0),
-                ..Default::default()
-            },
-            sprite: Sprite {
-                color: Color::rgb(0.5, 0.5, 1.0),
-                ..Default::default()
-            },
+            material: materials.add(Color::rgb(0.5, 0.5, 1.0).into()),
+            transform: Transform::from_xyz(0.0, -215.0, 0.0),
+            sprite: Sprite::new(Vec2::new(120.0, 30.0)),
             ..Default::default()
         })
         .insert(Paddle { speed: 500.0 })
@@ -70,15 +72,9 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     // ball
     commands
         .spawn_bundle(SpriteBundle {
-            transform: Transform {
-                scale: Vec3::new(30.0, 30.0, 0.0),
-                translation: Vec3::new(0.0, -50.0, 1.0),
-                ..Default::default()
-            },
-            sprite: Sprite {
-                color: Color::rgb(1.0, 0.5, 0.5),
-                ..Default::default()
-            },
+            material: materials.add(Color::rgb(1.0, 0.5, 0.5).into()),
+            transform: Transform::from_xyz(0.0, -50.0, 1.0),
+            sprite: Sprite::new(Vec2::new(30.0, 30.0)),
             ..Default::default()
         })
         .insert(Ball {
@@ -120,67 +116,43 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     });
 
     // Add walls
-    let wall_color = Color::rgb(0.8, 0.8, 0.8);
+    let wall_material = materials.add(Color::rgb(0.8, 0.8, 0.8).into());
     let wall_thickness = 10.0;
     let bounds = Vec2::new(900.0, 600.0);
 
     // left
     commands
         .spawn_bundle(SpriteBundle {
-            transform: Transform {
-                translation: Vec3::new(-bounds.x / 2.0, 0.0, 0.0),
-                scale: Vec3::new(wall_thickness, bounds.y + wall_thickness, 1.0),
-                ..Default::default()
-            },
-            sprite: Sprite {
-                color: wall_color,
-                ..Default::default()
-            },
+            material: wall_material.clone(),
+            transform: Transform::from_xyz(-bounds.x / 2.0, 0.0, 0.0),
+            sprite: Sprite::new(Vec2::new(wall_thickness, bounds.y + wall_thickness)),
             ..Default::default()
         })
         .insert(Collider::Solid);
     // right
     commands
         .spawn_bundle(SpriteBundle {
-            transform: Transform {
-                translation: Vec3::new(bounds.x / 2.0, 0.0, 0.0),
-                scale: Vec3::new(wall_thickness, bounds.y + wall_thickness, 1.0),
-                ..Default::default()
-            },
-            sprite: Sprite {
-                color: wall_color,
-                ..Default::default()
-            },
+            material: wall_material.clone(),
+            transform: Transform::from_xyz(bounds.x / 2.0, 0.0, 0.0),
+            sprite: Sprite::new(Vec2::new(wall_thickness, bounds.y + wall_thickness)),
             ..Default::default()
         })
         .insert(Collider::Solid);
     // bottom
     commands
         .spawn_bundle(SpriteBundle {
-            transform: Transform {
-                translation: Vec3::new(0.0, -bounds.y / 2.0, 0.0),
-                scale: Vec3::new(bounds.x + wall_thickness, wall_thickness, 1.0),
-                ..Default::default()
-            },
-            sprite: Sprite {
-                color: wall_color,
-                ..Default::default()
-            },
+            material: wall_material.clone(),
+            transform: Transform::from_xyz(0.0, -bounds.y / 2.0, 0.0),
+            sprite: Sprite::new(Vec2::new(bounds.x + wall_thickness, wall_thickness)),
             ..Default::default()
         })
         .insert(Collider::Solid);
     // top
     commands
         .spawn_bundle(SpriteBundle {
-            transform: Transform {
-                translation: Vec3::new(0.0, bounds.y / 2.0, 0.0),
-                scale: Vec3::new(bounds.x + wall_thickness, wall_thickness, 1.0),
-                ..Default::default()
-            },
-            sprite: Sprite {
-                color: wall_color,
-                ..Default::default()
-            },
+            material: wall_material,
+            transform: Transform::from_xyz(0.0, bounds.y / 2.0, 0.0),
+            sprite: Sprite::new(Vec2::new(bounds.x + wall_thickness, wall_thickness)),
             ..Default::default()
         })
         .insert(Collider::Solid);
@@ -189,11 +161,11 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     let brick_rows = 4;
     let brick_columns = 5;
     let brick_spacing = 20.0;
-    let brick_size = Vec3::new(150.0, 30.0, 1.0);
+    let brick_size = Vec2::new(150.0, 30.0);
     let bricks_width = brick_columns as f32 * (brick_size.x + brick_spacing) - brick_spacing;
     // center the bricks and move them up a bit
     let bricks_offset = Vec3::new(-(bricks_width - brick_size.x) / 2.0, 100.0, 0.0);
-    let brick_color = Color::rgb(0.5, 0.5, 1.0);
+    let brick_material = materials.add(Color::rgb(0.5, 0.5, 1.0).into());
     for row in 0..brick_rows {
         let y_position = row as f32 * (brick_size.y + brick_spacing);
         for column in 0..brick_columns {
@@ -205,15 +177,9 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
             // brick
             commands
                 .spawn_bundle(SpriteBundle {
-                    sprite: Sprite {
-                        color: brick_color,
-                        ..Default::default()
-                    },
-                    transform: Transform {
-                        translation: brick_position,
-                        scale: brick_size,
-                        ..Default::default()
-                    },
+                    material: brick_material.clone(),
+                    sprite: Sprite::new(brick_size),
+                    transform: Transform::from_translation(brick_position),
                     ..Default::default()
                 })
                 .insert(Collider::Scorable);
@@ -222,6 +188,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 }
 
 fn paddle_movement_system(
+    time: Res<Time>,
     keyboard_input: Res<Input<KeyCode>>,
     mut query: Query<(&Paddle, &mut Transform)>,
 ) {
@@ -237,14 +204,14 @@ fn paddle_movement_system(
 
     let translation = &mut transform.translation;
     // move the paddle horizontally
-    translation.x += direction * paddle.speed * TIME_STEP;
+    translation.x += direction * paddle.speed * time.fixed_delta_seconds();
     // bound the paddle within the walls
     translation.x = translation.x.min(380.0).max(-380.0);
 }
 
 fn ball_movement_system(mut ball_query: Query<(&Ball, &mut Transform)>) {
     let (ball, mut transform) = ball_query.single_mut();
-    transform.translation += ball.velocity * TIME_STEP;
+    transform.translation += ball.velocity * time.fixed_delta_seconds();
 }
 
 fn scoreboard_system(scoreboard: Res<Scoreboard>, mut query: Query<&mut Text>) {
@@ -255,20 +222,20 @@ fn scoreboard_system(scoreboard: Res<Scoreboard>, mut query: Query<&mut Text>) {
 fn ball_collision_system(
     mut commands: Commands,
     mut scoreboard: ResMut<Scoreboard>,
-    mut ball_query: Query<(&mut Ball, &Transform)>,
-    collider_query: Query<(Entity, &Collider, &Transform)>,
+    mut ball_query: Query<(&mut Ball, &Transform, &Sprite)>,
+    collider_query: Query<(Entity, &Collider, &Transform, &Sprite)>,
 ) {
-    let (mut ball, ball_transform) = ball_query.single_mut();
-    let ball_size = ball_transform.scale.truncate();
+    let (mut ball, ball_transform, sprite) = ball_query.single_mut();
+    let ball_size = sprite.size;
     let velocity = &mut ball.velocity;
 
     // check collision with walls
-    for (collider_entity, collider, transform) in collider_query.iter() {
+    for (collider_entity, collider, transform, sprite) in collider_query.iter() {
         let collision = collide(
             ball_transform.translation,
             ball_size,
             transform.translation,
-            transform.scale.truncate(),
+            sprite.size,
         );
         if let Some(collision) = collision {
             // scorable colliders should be despawned and increment the scoreboard on collision
@@ -288,7 +255,6 @@ fn ball_collision_system(
                 Collision::Right => reflect_x = velocity.x < 0.0,
                 Collision::Top => reflect_y = velocity.y < 0.0,
                 Collision::Bottom => reflect_y = velocity.y > 0.0,
-                Collision::Inside => { /* do nothing */ }
             }
 
             // reflect velocity on the x-axis if we hit something on the x-axis
diff --git a/examples/shader/animate_shader.rs b/examples/shader/animate_shader.rs
index 66c79104e2cf1d..e59de3447e2dbf 100644
--- a/examples/shader/animate_shader.rs
+++ b/examples/shader/animate_shader.rs
@@ -1,261 +1,125 @@
 use bevy::{
-    core_pipeline::Transparent3d,
-    ecs::system::{lifetimeless::SRes, SystemParamItem},
-    pbr::{
-        DrawMesh, MeshPipeline, MeshPipelineKey, MeshUniform, SetMeshBindGroup,
-        SetMeshViewBindGroup,
-    },
     prelude::*,
+    reflect::TypeUuid,
     render::{
-        mesh::MeshVertexBufferLayout,
-        render_asset::RenderAssets,
-        render_phase::{
-            AddRenderCommand, DrawFunctions, EntityRenderCommand, RenderCommandResult, RenderPhase,
-            SetItemPipeline, TrackedRenderPass,
-        },
-        render_resource::*,
-        renderer::{RenderDevice, RenderQueue},
-        view::{ComputedVisibility, ExtractedView, Msaa, Visibility},
-        RenderApp, RenderStage,
+        mesh::shape,
+        pipeline::{PipelineDescriptor, RenderPipeline},
+        render_graph::{base, RenderGraph, RenderResourcesNode},
+        renderer::RenderResources,
+        shader::{ShaderStage, ShaderStages},
     },
 };
 
-fn main() {
+/// This example shows how to animate a shader, by passing the global `time.seconds_since_startup()`
+/// via a 'TimeComponent` to the shader.
+pub fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_plugin(CustomMaterialPlugin)
         .add_startup_system(setup)
+        .add_system(animate_shader)
         .run();
 }
 
-fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
-    // cube
-    commands.spawn().insert_bundle((
-        meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-        Transform::from_xyz(0.0, 0.5, 0.0),
-        GlobalTransform::default(),
-        CustomMaterial,
-        Visibility::default(),
-        ComputedVisibility::default(),
-    ));
-
-    // camera
-    commands.spawn_bundle(PerspectiveCameraBundle {
-        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..Default::default()
-    });
+#[derive(Component, RenderResources, Default, TypeUuid)]
+#[uuid = "463e4b8a-d555-4fc2-ba9f-4c880063ba92"]
+struct TimeUniform {
+    value: f32,
 }
 
-#[derive(Component)]
-struct CustomMaterial;
+const VERTEX_SHADER: &str = r#"
+#version 450
 
-pub struct CustomMaterialPlugin;
+layout(location = 0) in vec3 Vertex_Position;
+layout(location = 1) in vec2 Vertex_Uv;
+layout(location = 0) out vec2 v_Uv;
 
-impl Plugin for CustomMaterialPlugin {
-    fn build(&self, app: &mut App) {
-        let render_device = app.world.resource::<RenderDevice>();
-        let buffer = render_device.create_buffer(&BufferDescriptor {
-            label: Some("time uniform buffer"),
-            size: std::mem::size_of::<f32>() as u64,
-            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
+layout(set = 0, binding = 0) uniform CameraViewProj {
+    mat4 ViewProj;
+};
 
-        app.sub_app_mut(RenderApp)
-            .add_render_command::<Transparent3d, DrawCustom>()
-            .insert_resource(TimeMeta {
-                buffer,
-                bind_group: None,
-            })
-            .init_resource::<CustomPipeline>()
-            .init_resource::<SpecializedMeshPipelines<CustomPipeline>>()
-            .add_system_to_stage(RenderStage::Extract, extract_time)
-            .add_system_to_stage(RenderStage::Extract, extract_custom_material)
-            .add_system_to_stage(RenderStage::Prepare, prepare_time)
-            .add_system_to_stage(RenderStage::Queue, queue_custom)
-            .add_system_to_stage(RenderStage::Queue, queue_time_bind_group);
-    }
-}
+layout(set = 1, binding = 0) uniform Transform {
+    mat4 Model;
+};
 
-// extract the `CustomMaterial` component into the render world
-fn extract_custom_material(
-    mut commands: Commands,
-    mut previous_len: Local<usize>,
-    mut query: Query<Entity, With<CustomMaterial>>,
-) {
-    let mut values = Vec::with_capacity(*previous_len);
-    for entity in query.iter_mut() {
-        values.push((entity, (CustomMaterial,)));
-    }
-    *previous_len = values.len();
-    commands.insert_or_spawn_batch(values);
+void main() {
+    gl_Position = ViewProj * Model * vec4(Vertex_Position, 1.0);
+    v_Uv = Vertex_Uv;
 }
+"#;
 
-// add each entity with a mesh and a `CustomMaterial` to every view's `Transparent3d` render phase using the `CustomPipeline`
-#[allow(clippy::too_many_arguments)]
-fn queue_custom(
-    transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
-    custom_pipeline: Res<CustomPipeline>,
-    msaa: Res<Msaa>,
-    mut pipelines: ResMut<SpecializedMeshPipelines<CustomPipeline>>,
-    mut pipeline_cache: ResMut<RenderPipelineCache>,
-    render_meshes: Res<RenderAssets<Mesh>>,
-    material_meshes: Query<(Entity, &MeshUniform, &Handle<Mesh>), With<CustomMaterial>>,
-    mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
-) {
-    let draw_custom = transparent_3d_draw_functions
-        .read()
-        .get_id::<DrawCustom>()
-        .unwrap();
+const FRAGMENT_SHADER: &str = r#"
+#version 450
 
-    let key = MeshPipelineKey::from_msaa_samples(msaa.samples)
-        | MeshPipelineKey::from_primitive_topology(PrimitiveTopology::TriangleList);
+layout(location = 0) in vec2 v_Uv;
+layout(location = 0) out vec4 o_Target;
 
-    for (view, mut transparent_phase) in views.iter_mut() {
-        let view_matrix = view.transform.compute_matrix();
-        let view_row_2 = view_matrix.row(2);
-        for (entity, mesh_uniform, mesh_handle) in material_meshes.iter() {
-            if let Some(mesh) = render_meshes.get(mesh_handle) {
-                let pipeline = pipelines
-                    .specialize(&mut pipeline_cache, &custom_pipeline, key, &mesh.layout)
-                    .unwrap();
-                transparent_phase.add(Transparent3d {
-                    entity,
-                    pipeline,
-                    draw_function: draw_custom,
-                    distance: view_row_2.dot(mesh_uniform.transform.col(3)),
-                });
-            }
-        }
-    }
-}
+layout(set = 2, binding = 0) uniform TimeUniform_value {
+    float time;
+};
 
-#[derive(Default)]
-struct ExtractedTime {
-    seconds_since_startup: f32,
-}
+void main() {
+    float speed = 0.7;
+    float translation = sin(time * speed);
+    float percentage = 0.6;
+    float threshold = v_Uv.x + translation * percentage;
 
-// extract the passed time into a resource in the render world
-fn extract_time(mut commands: Commands, time: Res<Time>) {
-    commands.insert_resource(ExtractedTime {
-        seconds_since_startup: time.seconds_since_startup() as f32,
-    });
-}
+    vec3 red = vec3(1., 0., 0.);
+    vec3 blue = vec3(0., 0., 1.);
+    vec3 mixed = mix(red, blue, threshold);
 
-struct TimeMeta {
-    buffer: Buffer,
-    bind_group: Option<BindGroup>,
+    o_Target = vec4(mixed, 1.0);
 }
+"#;
 
-// write the extracted time into the corresponding uniform buffer
-fn prepare_time(
-    time: Res<ExtractedTime>,
-    time_meta: ResMut<TimeMeta>,
-    render_queue: Res<RenderQueue>,
+fn setup(
+    mut commands: Commands,
+    mut pipelines: ResMut<Assets<PipelineDescriptor>>,
+    mut shaders: ResMut<Assets<Shader>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut render_graph: ResMut<RenderGraph>,
 ) {
-    render_queue.write_buffer(
-        &time_meta.buffer,
-        0,
-        bevy::core::cast_slice(&[time.seconds_since_startup]),
+    // Create a new shader pipeline.
+    let pipeline_handle = pipelines.add(PipelineDescriptor::default_config(ShaderStages {
+        vertex: shaders.add(Shader::from_glsl(ShaderStage::Vertex, VERTEX_SHADER)),
+        fragment: Some(shaders.add(Shader::from_glsl(ShaderStage::Fragment, FRAGMENT_SHADER))),
+    }));
+
+    // Add a `RenderResourcesNode` to our `RenderGraph`. This will bind `TimeComponent` to our
+    // shader.
+    render_graph.add_system_node(
+        "time_uniform",
+        RenderResourcesNode::<TimeUniform>::new(true),
     );
-}
 
-// create a bind group for the time uniform buffer
-fn queue_time_bind_group(
-    render_device: Res<RenderDevice>,
-    mut time_meta: ResMut<TimeMeta>,
-    pipeline: Res<CustomPipeline>,
-) {
-    let bind_group = render_device.create_bind_group(&BindGroupDescriptor {
-        label: None,
-        layout: &pipeline.time_bind_group_layout,
-        entries: &[BindGroupEntry {
-            binding: 0,
-            resource: time_meta.buffer.as_entire_binding(),
-        }],
-    });
-    time_meta.bind_group = Some(bind_group);
-}
-
-pub struct CustomPipeline {
-    shader: Handle<Shader>,
-    mesh_pipeline: MeshPipeline,
-    time_bind_group_layout: BindGroupLayout,
-}
-
-impl FromWorld for CustomPipeline {
-    fn from_world(world: &mut World) -> Self {
-        let world = world.cell();
-        let asset_server = world.get_resource::<AssetServer>().unwrap();
-        let shader = asset_server.load("shaders/animate_shader.wgsl");
-
-        let render_device = world.get_resource_mut::<RenderDevice>().unwrap();
-        let time_bind_group_layout =
-            render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-                label: Some("time bind group"),
-                entries: &[BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: BufferSize::new(std::mem::size_of::<f32>() as u64),
-                    },
-                    count: None,
-                }],
-            });
-
-        let mesh_pipeline = world.get_resource::<MeshPipeline>().unwrap();
-
-        CustomPipeline {
-            shader,
-            mesh_pipeline: mesh_pipeline.clone(),
-            time_bind_group_layout,
-        }
-    }
-}
-
-impl SpecializedMeshPipeline for CustomPipeline {
-    type Key = MeshPipelineKey;
+    // Add a `RenderGraph` edge connecting our new "time_component" node to the main pass node. This
+    // ensures that "time_component" runs before the main pass.
+    render_graph
+        .add_node_edge("time_uniform", base::node::MAIN_PASS)
+        .unwrap();
 
-    fn specialize(
-        &self,
-        key: Self::Key,
-        layout: &MeshVertexBufferLayout,
-    ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError> {
-        let mut descriptor = self.mesh_pipeline.specialize(key, layout)?;
-        descriptor.vertex.shader = self.shader.clone();
-        descriptor.fragment.as_mut().unwrap().shader = self.shader.clone();
-        descriptor.layout = Some(vec![
-            self.mesh_pipeline.view_layout.clone(),
-            self.mesh_pipeline.mesh_layout.clone(),
-            self.time_bind_group_layout.clone(),
-        ]);
-        Ok(descriptor)
-    }
+    // Spawn a quad and insert the `TimeComponent`.
+    commands
+        .spawn_bundle(MeshBundle {
+            mesh: meshes.add(Mesh::from(shape::Quad::new(Vec2::new(5.0, 5.0)))),
+            render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
+                pipeline_handle,
+            )]),
+            transform: Transform::from_xyz(0.0, 0.0, 0.0),
+            ..Default::default()
+        })
+        .insert(TimeUniform { value: 0.0 });
+
+    // Spawn a camera.
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(0.0, 0.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
 }
 
-type DrawCustom = (
-    SetItemPipeline,
-    SetMeshViewBindGroup<0>,
-    SetMeshBindGroup<1>,
-    SetTimeBindGroup<2>,
-    DrawMesh,
-);
-
-struct SetTimeBindGroup<const I: usize>;
-impl<const I: usize> EntityRenderCommand for SetTimeBindGroup<I> {
-    type Param = SRes<TimeMeta>;
-
-    fn render<'w>(
-        _view: Entity,
-        _item: Entity,
-        time_meta: SystemParamItem<'w, '_, Self::Param>,
-        pass: &mut TrackedRenderPass<'w>,
-    ) -> RenderCommandResult {
-        let time_bind_group = time_meta.into_inner().bind_group.as_ref().unwrap();
-        pass.set_bind_group(I, time_bind_group, &[]);
-
-        RenderCommandResult::Success
-    }
+/// In this system we query for the `TimeComponent` and global `Time` resource, and set
+/// `time.seconds_since_startup()` as the `value` of the `TimeComponent`. This value will be
+/// accessed by the fragment shader and used to animate the shader.
+fn animate_shader(time: Res<Time>, mut query: Query<&mut TimeUniform>) {
+    let mut time_uniform = query.single_mut();
+    time_uniform.value = time.seconds_since_startup();
 }
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index 238579eedb183e..1bdb982298e703 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -106,7 +106,7 @@ fn text_update_system(diagnostics: Res<Diagnostics>, mut query: Query<&mut Text,
 
 fn text_color_system(time: Res<Time>, mut query: Query<&mut Text, With<ColorText>>) {
     for mut text in query.iter_mut() {
-        let seconds = time.seconds_since_startup() as f32;
+        let seconds = time.seconds_since_startup();
         // We used the `Text::with_section` helper method, but it is still just a `Text`,
         // so to update it, we are still updating the one and only section
         text.sections[0].style.color = Color::Rgba {

From 4013f8bd708e1879487d6204bd27ef5e5c20c852 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 21 Oct 2021 14:41:42 -0700
Subject: [PATCH 02/27] Add setters for TimeAccumulator

Make it possible for users to cache their own accumulator states if they want to run multiple for whatever arcane reason.
---
 crates/bevy_core/src/time/fixed_timestep.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 59d480b65f12fd..48237e638131bd 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -65,6 +65,14 @@ impl TimeAccumulator {
         self.steps.checked_sub(1)
     }
 
+    pub fn set_time(&mut self, time: Duration) {
+        self.time = time;
+    }
+
+    pub fn set_steps(&mut self, steps: usize) {
+        self.steps = steps;
+    }
+
     pub fn reset(&mut self) {
         self.time = 0.0;
         self.steps = 0;

From 8d23b29d6c29a7fa7488a117ef7853195150f1d6 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 21 Oct 2021 15:11:14 -0700
Subject: [PATCH 03/27] fix errors, make cargo happy, and stop time paradoxes

div_duration not stable, whoops
I'm sorry, but we can't go back in time,
---
 crates/bevy_core/src/lib.rs                 |  2 +-
 crates/bevy_core/src/time/fixed_timestep.rs | 36 +++++---------
 crates/bevy_core/src/time/time.rs           | 55 ++++++++++++++-------
 examples/3d/spawner.rs                      |  3 +-
 examples/ecs/fixed_timestep.rs              | 37 +++++++-------
 examples/ecs/iter_combinations.rs           | 35 ++++++-------
 examples/game/alien_cake_addict.rs          |  6 +--
 examples/game/breakout.rs                   |  2 +-
 8 files changed, 91 insertions(+), 85 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 10daf75022e312..3e61aeeb72fba6 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -15,7 +15,7 @@ pub use time::*;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        DefaultTaskPoolOptions, EntityLabels, FixedTimestep, Labels, Name, Time, Timer
+        DefaultTaskPoolOptions, EntityLabels, FixedTimestep, Labels, Name, Time, Timer,
     };
 }
 
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 48237e638131bd..009172f0b8d6ca 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -1,10 +1,6 @@
-use bevy_ecs::{
-    schedule::ShouldRun,
-    system::{Res, ResMut}
-};
-use bevy_utils::Duration;
+use bevy_ecs::{schedule::ShouldRun, system::ResMut};
 
-use crate::Time;
+use bevy_utils::Duration;
 
 #[derive(Debug, Clone)]
 pub struct TimeAccumulator {
@@ -14,19 +10,16 @@ pub struct TimeAccumulator {
 
 impl Default for TimeAccumulator {
     fn default() -> Self {
-        Self { 
-            time: Duration::from_secs(0), 
-            steps: 0
+        Self {
+            time: Duration::from_secs(0),
+            steps: 0,
         }
     }
 }
 
 impl TimeAccumulator {
     pub fn new(time: Duration, steps: usize) -> Self {
-        Self { 
-            time, 
-            steps
-        }
+        Self { time, steps }
     }
 
     /// The number of accrued steps.
@@ -43,14 +36,14 @@ impl TimeAccumulator {
 
     /// The amount of time accrued toward the next step as [`f32`] % of timestep.
     pub fn overstep_percentage(&self, timestep: Duration) -> f32 {
-        self.time.div_duration_f32(timestep)
+        self.time.as_secs_f32() / timestep.as_secs_f32()
     }
 
     /// The amount of time accrued toward the next step as [`f64`] % of timestep.
     pub fn overstep_percentage_f64(&self, timestep: Duration) -> f64 {
-        self.time.div_duration_f64(timestep)
+        self.time.as_secs_f64() / timestep.as_secs_f64()
     }
-    
+
     /// Add to the stored time, then convert into as many steps as possible.
     pub fn add_time(&mut self, time: Duration, timestep: Duration) {
         self.time += time;
@@ -74,22 +67,19 @@ impl TimeAccumulator {
     }
 
     pub fn reset(&mut self) {
-        self.time = 0.0;
+        self.time = Duration::from_secs(0);
         self.steps = 0;
     }
 }
 
-
 pub struct FixedTimestep;
 
 impl FixedTimestep {
-    pub fn step (
-        mut accumulator: ResMut<TimeAccumulator>
-    ) -> ShouldRun {
-        if let Some(_) = accumulator.sub_step() {
+    pub fn step(mut accumulator: ResMut<TimeAccumulator>) -> ShouldRun {
+        if accumulator.sub_step().is_some() {
             ShouldRun::YesAndCheckAgain
         } else {
             ShouldRun::No
         }
     }
-}
\ No newline at end of file
+}
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index c6c7b710a41dda..d2186df03a3fd0 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -1,8 +1,7 @@
 use bevy_ecs::system::ResMut;
 use bevy_utils::{Duration, Instant};
 
-use bevy_ecs::system::ResMut;
-use bevy_utils::{Duration, Instant};
+use crate::TimeAccumulator;
 
 /// Tracks time elapsed since the previous update and total frame time since the app was started.
 #[derive(Debug, Clone)]
@@ -94,8 +93,8 @@ impl Time {
     pub fn fixed_delta_seconds_f64(&self) -> f64 {
         self.fixed_delta_seconds_f64
     }
-    
-    /// Changes fixed delta. Users are strongly cautioned against modifying 
+
+    /// Changes fixed delta. Users are strongly cautioned against modifying
     /// the step rate this way, except during startup.
     /// Prefer [`Time::set_speed_multiplier`] to ensure consistent simulation behavior.
     pub fn set_steps_per_second(&mut self, steps: f32) {
@@ -121,6 +120,7 @@ impl Time {
     /// Set rate app time advances relative to true clock time.
     #[inline]
     pub fn set_speed_multiplier(&mut self, speed_multiplier: f32) {
+        assert!(speed_multiplier > 0.0);
         self.speed_multiplier = speed_multiplier;
     }
 
@@ -172,12 +172,12 @@ impl Time {
     }
 }
 
-pub(crate) fn time_system(
-    mut time: ResMut<Time>,
-    mut accumulator: ResMut<TimeAccumulator>
-) {
+pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<TimeAccumulator>) {
     time.update();
-    accumulator.add_time(time.delta().mul_f64(time.speed_multiplier_f64()), time.fixed_delta());
+    accumulator.add_time(
+        time.delta().mul_f64(time.speed_multiplier_f64()),
+        time.fixed_delta(),
+    );
 }
 
 #[cfg(test)]
@@ -204,7 +204,10 @@ mod tests {
         // Fixed delta is fixed.
         assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
         assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+        assert_eq!(
+            time.fixed_delta_seconds_f64(),
+            time.fixed_delta().as_secs_f64()
+        );
 
         // Sanity check.
         assert_eq!(time.last_update(), None);
@@ -226,7 +229,10 @@ mod tests {
         // Fixed delta is still fixed.
         assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
         assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+        assert_eq!(
+            time.fixed_delta_seconds_f64(),
+            time.fixed_delta().as_secs_f64()
+        );
 
         // Sanity check.
         assert_eq!(time.last_update(), Some(first_update_instant));
@@ -234,7 +240,10 @@ mod tests {
 
         // App advances 1:1 to with real time.
         assert_eq!(time.speed_multiplier(), 1.0);
-        assert_eq!(time.time_since_startup(), first_update_instant - start_instant);
+        assert_eq!(
+            time.time_since_startup(),
+            first_update_instant - start_instant
+        );
 
         // Update `time` again and check results
         let second_update_instant = Instant::now();
@@ -249,7 +258,10 @@ mod tests {
         // Fixed delta is STILL fixed.
         assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
         assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+        assert_eq!(
+            time.fixed_delta_seconds_f64(),
+            time.fixed_delta().as_secs_f64()
+        );
 
         // Sanity check.
         assert_eq!(time.last_update(), Some(second_update_instant));
@@ -257,11 +269,14 @@ mod tests {
 
         // App advances 1:1 to with real time.
         assert_eq!(time.speed_multiplier(), 1.0);
-        assert_eq!(time.time_since_startup(), second_update_instant - start_instant);
+        assert_eq!(
+            time.time_since_startup(),
+            second_update_instant - start_instant
+        );
 
         // Make app time advance at 2x the rate of real world time.
         time.set_speed_multiplier(2.0);
-        
+
         // Update `time` again 1 second later.
         let third_update_instant = second_update_instant + Duration::from_secs(1);
 
@@ -274,7 +289,10 @@ mod tests {
         // Fixed delta is still fixed.
         assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
         assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(time.fixed_delta_seconds_f64(), time.fixed_delta().as_secs_f64());
+        assert_eq!(
+            time.fixed_delta_seconds_f64(),
+            time.fixed_delta().as_secs_f64()
+        );
 
         // Sanity check.
         assert_eq!(time.last_update(), Some(third_update_instant));
@@ -282,6 +300,9 @@ mod tests {
 
         // App is advancing at 2x speed, so app time should have advanced by 2 seconds.
         assert_eq!(time.speed_multiplier(), 2.0);
-        assert_eq!(time.time_since_startup(), second_update_instant - start_instant + Duration::from_secs(2));
+        assert_eq!(
+            time.time_since_startup(),
+            second_update_instant - start_instant + Duration::from_secs(2)
+        );
     }
 }
diff --git a/examples/3d/spawner.rs b/examples/3d/spawner.rs
index 9f54fceb4c504d..fecf9d22aad52f 100644
--- a/examples/3d/spawner.rs
+++ b/examples/3d/spawner.rs
@@ -30,8 +30,7 @@ fn move_cubes(
     for (mut transform, material_handle) in query.iter_mut() {
         let material = materials.get_mut(material_handle).unwrap();
         transform.translation += Vec3::new(1.0, 0.0, 0.0) * time.delta_seconds();
-        material.base_color =
-            Color::BLUE * Vec3::splat((3.0 * time.seconds_since_startup()).sin());
+        material.base_color = Color::BLUE * Vec3::splat((3.0 * time.seconds_since_startup()).sin());
     }
 }
 
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index 136ba2d856283a..3fe7fe40d342ca 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -23,28 +23,31 @@ fn main() {
         .run();
 }
 
-fn set_fixed_timestep(
-    mut time: ResMut<Time>,
-) {
-    time.set_steps_per_second(10);
+fn set_fixed_timestep(mut time: ResMut<Time>) {
+    time.set_steps_per_second(10.0);
 }
 
-fn frame_update(
-    mut last_time: Local<f32>,
-    time: Res<Time>,
-) {
-    info!("time since last frame_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<f32>,
-    time: Res<Time>,
-    accumulator: Res<TimeAccumulator>,
-) {
-    info!("time since last fixed_update: {}\n", time.seconds_since_startup() - *last_time);
+fn fixed_update(mut last_time: Local<f32>, time: Res<Time>, accumulator: Res<TimeAccumulator>) {
+    info!(
+        "time since last fixed_update: {}\n",
+        time.seconds_since_startup() - *last_time
+    );
     info!("fixed timestep: {}\n", time.fixed_delta_seconds());
-    info!("time accrued toward fixed_update: {}\n", accumulator.time());
-    info!("time accrued toward fixed_update (% of time.fixed_delta): {}", accumulator.overstep_percentage());
+    info!(
+        "time accrued toward next fixed_update: {}\n",
+        accumulator.overstep()
+    );
+    info!(
+        "time accrued toward next fixed_update (% of time.fixed_delta): {}",
+        accumulator.overstep_percentage(time.fixed_delta())
+    );
     *last_time = time.seconds_since_startup();
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index 2d137e0b7722af..67ef108067df44 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -6,24 +6,22 @@ struct FixedUpdateStage;
 
 fn main() {
     App::new()
-    .insert_resource(Msaa { samples: 4 })
-    .add_plugins(DefaultPlugins)
-    .add_startup_system(set_fixed_timestep)
-    .add_startup_system(generate_bodies)
-    .add_stage_after(
-        CoreStage::Update,
-        FixedUpdateStage,
-        SystemStage::parallel()
-        .with_run_criteria(FixedTimestep::step)
-        .with_system(interact_bodies)
-        .with_system(integrate),
-    )
-    .run();
+        .insert_resource(Msaa { samples: 4 })
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(set_fixed_timestep)
+        .add_startup_system(generate_bodies)
+        .add_stage_after(
+            CoreStage::Update,
+            FixedUpdateStage,
+            SystemStage::parallel()
+                .with_run_criteria(FixedTimestep::step)
+                .with_system(interact_bodies)
+                .with_system(integrate),
+        )
+        .run();
 }
 
-fn set_fixed_timestep(
-    mut time: ResMut<Time>,
-) {
+fn set_fixed_timestep(mut time: ResMut<Time>) {
     time.set_steps_per_second(100);
 }
 
@@ -149,10 +147,7 @@ fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)
     }
 }
 
-fn integrate(
-    time: Res<Time>,
-    mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>
-) {
+fn integrate(time: Res<Time>, mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>) {
     let dt_sq = time.fixed_delta_seconds() * time.fixed_delta_seconds();
     for (mut acceleration, mut transform, mut last_pos) in query.iter_mut() {
         // verlet integration
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index 9c30a7f743b132..5c1ab209eabfd7 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -69,10 +69,8 @@ struct Game {
     camera_is_focus: Vec3,
 }
 
-fn set_fixed_timestep(
-    mut time: ResMut<Time>,
-) {
-    time.set_steps_per_second(1 / 5.0);
+fn set_fixed_timestep(mut time: ResMut<Time>) {
+    time.set_steps_per_second(0.2);
 }
 
 const BOARD_SIZE_I: usize = 14;
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index ebfc7de2dcc5b3..d6261bc3199cf1 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -209,7 +209,7 @@ fn paddle_movement_system(
     translation.x = translation.x.min(380.0).max(-380.0);
 }
 
-fn ball_movement_system(mut ball_query: Query<(&Ball, &mut Transform)>) {
+fn ball_movement_system(time: Res<Time>, mut ball_query: Query<(&Ball, &mut Transform)>) {
     let (ball, mut transform) = ball_query.single_mut();
     transform.translation += ball.velocity * time.fixed_delta_seconds();
 }

From 2f63514445b6a67efe44f9333e3770e74db95861 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 21 Oct 2021 16:21:53 -0700
Subject: [PATCH 04/27] fix errors

---
 examples/ecs/fixed_timestep.rs    | 2 +-
 examples/ecs/iter_combinations.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index 3fe7fe40d342ca..8854bac7286569 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -43,7 +43,7 @@ fn fixed_update(mut last_time: Local<f32>, time: Res<Time>, accumulator: Res<Tim
     info!("fixed timestep: {}\n", time.fixed_delta_seconds());
     info!(
         "time accrued toward next fixed_update: {}\n",
-        accumulator.overstep()
+        accumulator.overstep().as_secs_f32()
     );
     info!(
         "time accrued toward next fixed_update (% of time.fixed_delta): {}",
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index 67ef108067df44..375d6f9590139c 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -22,7 +22,7 @@ fn main() {
 }
 
 fn set_fixed_timestep(mut time: ResMut<Time>) {
-    time.set_steps_per_second(100);
+    time.set_steps_per_second(100.0);
 }
 
 const GRAVITY_CONSTANT: f32 = 0.001;

From 60ddb6d9b6b9ade20eac306ed2422abafd13725e Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 21 Oct 2021 16:59:56 -0700
Subject: [PATCH 05/27] fixed test case I broke

since time updates first, the second update is the first dt we care about
---
 crates/bevy_core/src/time/time.rs | 21 +++++++--------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index d2186df03a3fd0..9795b87069822c 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -212,12 +212,12 @@ mod tests {
         // Sanity check.
         assert_eq!(time.last_update(), None);
         assert_eq!(time.startup(), start_instant);
-
-        // App advances 1:1 to with real time.
         assert_eq!(time.speed_multiplier(), 1.0);
         assert_eq!(time.time_since_startup(), Duration::from_secs(0));
 
-        // Update `time` and check results
+        // Update `time` and check results.
+        // The first update to `time` normally happens before other systems have run,
+        // so delta isn't "ready" until the second update.
         let first_update_instant = Instant::now();
 
         time.update_with_instant(first_update_instant);
@@ -237,20 +237,15 @@ mod tests {
         // Sanity check.
         assert_eq!(time.last_update(), Some(first_update_instant));
         assert_eq!(time.startup(), start_instant);
-
-        // App advances 1:1 to with real time.
         assert_eq!(time.speed_multiplier(), 1.0);
-        assert_eq!(
-            time.time_since_startup(),
-            first_update_instant - start_instant
-        );
+        assert_eq!(time.time_since_startup(), Duration::from_secs(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);
 
-        // At this point its safe to use time.delta().
         assert_eq!(time.delta(), second_update_instant - first_update_instant);
         assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
         assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
@@ -266,8 +261,6 @@ mod tests {
         // Sanity check.
         assert_eq!(time.last_update(), Some(second_update_instant));
         assert_eq!(time.startup(), start_instant);
-
-        // App advances 1:1 to with real time.
         assert_eq!(time.speed_multiplier(), 1.0);
         assert_eq!(
             time.time_since_startup(),
@@ -298,7 +291,7 @@ mod tests {
         assert_eq!(time.last_update(), Some(third_update_instant));
         assert_eq!(time.startup(), start_instant);
 
-        // App is advancing at 2x speed, so app time should have advanced by 2 seconds.
+        // App is advancing 2x real time speed, so app time should have advanced by 2 seconds.
         assert_eq!(time.speed_multiplier(), 2.0);
         assert_eq!(
             time.time_since_startup(),

From c22119528190eb8f14acef7935c243cbccc80b5d Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Fri, 22 Oct 2021 10:29:30 -0700
Subject: [PATCH 06/27] revert name back to FixedTimestepState

thought about it and the OG name definitely clarifies the purpose better
---
 crates/bevy_core/src/lib.rs                 | 2 +-
 crates/bevy_core/src/time/fixed_timestep.rs | 8 ++++----
 crates/bevy_core/src/time/time.rs           | 4 ++--
 examples/ecs/fixed_timestep.rs              | 4 ++--
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 3e61aeeb72fba6..340779901486a5 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -49,7 +49,7 @@ impl Plugin for CorePlugin {
             .create_default_pools(&mut app.world);
 
         app.init_resource::<Time>()
-            .init_resource::<TimeAccumulator>()
+            .init_resource::<FixedTimestepState>()
             .init_resource::<EntityLabels>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 009172f0b8d6ca..3614c637d06118 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -3,12 +3,12 @@ use bevy_ecs::{schedule::ShouldRun, system::ResMut};
 use bevy_utils::Duration;
 
 #[derive(Debug, Clone)]
-pub struct TimeAccumulator {
+pub struct FixedTimestepState {
     time: Duration,
     steps: usize,
 }
 
-impl Default for TimeAccumulator {
+impl Default for FixedTimestepState {
     fn default() -> Self {
         Self {
             time: Duration::from_secs(0),
@@ -17,7 +17,7 @@ impl Default for TimeAccumulator {
     }
 }
 
-impl TimeAccumulator {
+impl FixedTimestepState {
     pub fn new(time: Duration, steps: usize) -> Self {
         Self { time, steps }
     }
@@ -75,7 +75,7 @@ impl TimeAccumulator {
 pub struct FixedTimestep;
 
 impl FixedTimestep {
-    pub fn step(mut accumulator: ResMut<TimeAccumulator>) -> ShouldRun {
+    pub fn step(mut accumulator: ResMut<FixedTimestepState>) -> ShouldRun {
         if accumulator.sub_step().is_some() {
             ShouldRun::YesAndCheckAgain
         } else {
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 9795b87069822c..3c032541d5de2e 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -1,7 +1,7 @@
 use bevy_ecs::system::ResMut;
 use bevy_utils::{Duration, Instant};
 
-use crate::TimeAccumulator;
+use crate::FixedTimestepState;
 
 /// Tracks time elapsed since the previous update and total frame time since the app was started.
 #[derive(Debug, Clone)]
@@ -172,7 +172,7 @@ impl Time {
     }
 }
 
-pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<TimeAccumulator>) {
+pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) {
     time.update();
     accumulator.add_time(
         time.delta().mul_f64(time.speed_multiplier_f64()),
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index 8854bac7286569..26d5429376db1d 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -1,5 +1,5 @@
 use bevy::{
-    core::{FixedTimestep, TimeAccumulator},
+    core::{FixedTimestep, FixedTimestepState},
     prelude::*,
 };
 
@@ -35,7 +35,7 @@ fn frame_update(mut last_time: Local<f32>, time: Res<Time>) {
     *last_time = time.seconds_since_startup();
 }
 
-fn fixed_update(mut last_time: Local<f32>, time: Res<Time>, accumulator: Res<TimeAccumulator>) {
+fn fixed_update(mut last_time: Local<f32>, time: Res<Time>, accumulator: Res<FixedTimestepState>) {
     info!(
         "time since last fixed_update: {}\n",
         time.seconds_since_startup() - *last_time

From 636986d0e4d55a66c7af967386e164ab3dee3818 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Fri, 22 Oct 2021 10:35:37 -0700
Subject: [PATCH 07/27] actually subtract the steps

---
 crates/bevy_core/src/time/fixed_timestep.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 3614c637d06118..e89cbdd4d0d831 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -55,7 +55,9 @@ impl FixedTimestepState {
 
     /// Consume a stored step (if any).
     pub fn sub_step(&mut self) -> Option<usize> {
-        self.steps.checked_sub(1)
+        let remaining = self.steps.checked_sub(1);
+        self.steps = self.steps.saturating_sub(1);
+        remaining
     }
 
     pub fn set_time(&mut self, time: Duration) {

From 185f657c3f0a6c7159de0af407bf9680ae92be65 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Fri, 22 Oct 2021 10:47:13 -0700
Subject: [PATCH 08/27] update time_since_startup and timestep accumulator with
 the same float precision

---
 crates/bevy_core/src/time/time.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 3c032541d5de2e..a76f3996439d94 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -175,7 +175,7 @@ impl Time {
 pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) {
     time.update();
     accumulator.add_time(
-        time.delta().mul_f64(time.speed_multiplier_f64()),
+        time.delta().mul_f32(time.speed_multiplier()),
         time.fixed_delta(),
     );
 }

From 29e49eeda60fb263c65e5ccde334c1b05c390a83 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Fri, 22 Oct 2021 11:06:12 -0700
Subject: [PATCH 09/27] added test cases to fixed timestep

---
 crates/bevy_core/src/time/fixed_timestep.rs | 47 +++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index e89cbdd4d0d831..9c73af7cce91b1 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -85,3 +85,50 @@ impl FixedTimestep {
         }
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::FixedTimestepState;
+    use bevy_utils::Duration;
+
+    #[test]
+    fn test_methods() {
+        let mut accumulator = FixedTimestepState::default();
+
+        assert_eq!(accumulator.steps(), 0);
+        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+
+        accumulator.add_time(Duration::from_secs(5), Duration::from_secs(1));
+
+        assert_eq!(accumulator.steps(), 5);
+        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+
+        let steps_remaining = accumulator.sub_step();
+
+        assert_eq!(steps_remaining, Some(4));
+        assert_eq!(accumulator.steps(), 4);
+        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+
+        accumulator.set_time(Duration::from_secs(1));
+
+        assert_eq!(accumulator.steps(), 4);
+        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
+        
+        accumulator.set_steps(12);
+
+        assert_eq!(accumulator.steps(), 12);
+        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
+
+        accumulator.reset();
+
+        assert_eq!(accumulator.steps(), 0);
+        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+
+        let steps_remaining = accumulator.sub_step();
+        
+        assert_eq!(steps_remaining, None);
+        assert_eq!(accumulator.steps(), 0);
+        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+    }
+}
\ No newline at end of file

From 26b2b06f38761eaf33c39434266cd79626ad8605 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Fri, 22 Oct 2021 11:08:04 -0700
Subject: [PATCH 10/27] rustfmt

---
 crates/bevy_core/src/time/fixed_timestep.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 9c73af7cce91b1..09f77b684af223 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -86,7 +86,6 @@ impl FixedTimestep {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::FixedTimestepState;
@@ -114,7 +113,7 @@ mod tests {
 
         assert_eq!(accumulator.steps(), 4);
         assert_eq!(accumulator.overstep(), Duration::from_secs(1));
-        
+
         accumulator.set_steps(12);
 
         assert_eq!(accumulator.steps(), 12);
@@ -126,9 +125,9 @@ mod tests {
         assert_eq!(accumulator.overstep(), Duration::from_secs(0));
 
         let steps_remaining = accumulator.sub_step();
-        
+
         assert_eq!(steps_remaining, None);
         assert_eq!(accumulator.steps(), 0);
         assert_eq!(accumulator.overstep(), Duration::from_secs(0));
     }
-}
\ No newline at end of file
+}

From 479e7ed997858116f17deeefb01d53def79875b9 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Fri, 22 Oct 2021 12:41:31 -0700
Subject: [PATCH 11/27] three variants of time since startup

There's a non-zero duration between startup and the very first update to time. Fixed timestep starts accumulating with the latter. Not sure if it's important to know, but we can just save the first update instant if we need it later.
---
 crates/bevy_core/src/time/time.rs | 77 +++++++++++++++++++++++++++----
 1 file changed, 67 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index a76f3996439d94..423fe7c2079029 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -14,6 +14,7 @@ pub struct Time {
     fixed_delta_seconds_f64: f64,
     speed_multiplier: f32,
     time_since_startup: Duration,
+    first_update: Option<Instant>,
     last_update: Option<Instant>,
     startup: Instant,
 }
@@ -32,6 +33,7 @@ impl Default for Time {
             fixed_delta_seconds_f64: fixed_delta.as_secs_f64(),
             speed_multiplier: 1.0,
             time_since_startup: Duration::from_secs(0),
+            first_update: None,
             last_update: None,
             startup: Instant::now(),
         }
@@ -50,6 +52,9 @@ impl Time {
             self.delta_seconds = self.delta.as_secs_f32();
             self.delta_seconds_f64 = self.delta.as_secs_f64();
             self.time_since_startup += self.delta.mul_f32(self.speed_multiplier);
+        } else {
+            self.first_update = Some(instant);
+            self.time_since_startup += (instant - self.startup).mul_f32(self.speed_multiplier);
         }
 
         self.last_update = Some(instant);
@@ -94,9 +99,10 @@ impl Time {
         self.fixed_delta_seconds_f64
     }
 
-    /// Changes fixed delta. Users are strongly cautioned against modifying
+    /// Changes [`Time::fixed_delta`]. Users are strongly cautioned against modifying
     /// the step rate this way, except during startup.
-    /// Prefer [`Time::set_speed_multiplier`] to ensure consistent simulation behavior.
+    /// Prefer [`Time::set_speed_multiplier`] to ensure that consumers of
+    /// [`Time::fixed_delta`] produce consistent behavior.
     pub fn set_steps_per_second(&mut self, steps: f32) {
         self.fixed_delta = Duration::from_secs_f32(1.0 / steps);
         self.fixed_delta_seconds = self.fixed_delta.as_secs_f32();
@@ -117,13 +123,19 @@ impl Time {
         self.speed_multiplier as f64
     }
 
-    /// Set rate app time advances relative to true clock time.
+    /// Set rate app time advances relative to true clock time. Must be >= 0.0.
     #[inline]
     pub fn set_speed_multiplier(&mut self, speed_multiplier: f32) {
-        assert!(speed_multiplier > 0.0);
+        assert!(speed_multiplier >= 0.0);
         self.speed_multiplier = speed_multiplier;
     }
 
+    /// The ['Instant'] when [`Time::update`] was first called, if it exists.
+    #[inline]
+    pub fn first_update(&self) -> Option<Instant> {
+        self.first_update
+    }
+
     /// The ['Instant'] when [`Time::update`] was last called, if it exists.
     #[inline]
     pub fn last_update(&self) -> Option<Instant> {
@@ -137,39 +149,64 @@ impl Time {
     }
 
     /// The time since startup, as [`Duration`]. Affected by speed multiplier.
-    #[inline]
+    /// Sampled during the latest update.
     pub fn time_since_startup(&self) -> Duration {
         self.time_since_startup
     }
 
     /// The time since startup, as [`f32`] seconds. Affected by speed multiplier.
+    /// Sampled during the latest update.
     #[inline]
     pub fn seconds_since_startup(&self) -> f32 {
         self.time_since_startup().as_secs_f32()
     }
 
     /// The time since startup, as [`f64`] seconds. Affected by speed multiplier.
+    /// Sampled during the latest update.
     #[inline]
     pub fn seconds_since_startup_f64(&self) -> f64 {
         self.time_since_startup().as_secs_f64()
     }
 
-    /// The true clock time since startup, as [`Duration`]. May be different every call.
+    /// The time since startup, as [`Duration`]. Unaffected by speed multiplier.
+    /// Sampled during the latest update.
     pub fn real_time_since_startup(&self) -> Duration {
-        Instant::now() - self.startup
+        self.last_update.unwrap_or(self.startup) - self.startup
     }
 
-    /// The true clock time since startup, as [`f32`] seconds. May be different every call.
+    /// The time since startup, as [`f32`] seconds. Unaffected by speed multiplier.
+    /// Sampled during the latest update.
     #[inline]
     pub fn real_seconds_since_startup(&self) -> f32 {
         self.real_time_since_startup().as_secs_f32()
     }
 
-    /// The true clock time since startup, as [`f64`] seconds. May be different every call.
+    /// The time since startup, as [`f64`] seconds. Unaffected by speed multiplier.
+    /// Sampled during the latest update.
     #[inline]
     pub fn real_seconds_since_startup_f64(&self) -> f64 {
         self.real_time_since_startup().as_secs_f64()
     }
+
+    /// The time since startup, as [`Duration`]. Unaffected by speed multiplier.
+    /// Sampled at call.
+    pub fn live_real_time_since_startup(&self) -> Duration {
+        Instant::now() - self.startup
+    }
+
+    /// The time since startup, as [`f32`] seconds. Unaffected by speed multiplier.
+    /// Sampled at call.
+    #[inline]
+    pub fn live_real_seconds_since_startup(&self) -> f32 {
+        self.live_real_time_since_startup().as_secs_f32()
+    }
+
+    /// The time since startup, as [`f64`] seconds. Unaffected by speed multiplier.
+    /// Sampled at call.
+    #[inline]
+    pub fn live_real_seconds_since_startup_f64(&self) -> f64 {
+        self.live_real_time_since_startup().as_secs_f64()
+    }
 }
 
 pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) {
@@ -210,10 +247,12 @@ mod tests {
         );
 
         // Sanity check.
+        assert_eq!(time.first_update(), None);
         assert_eq!(time.last_update(), None);
         assert_eq!(time.startup(), start_instant);
         assert_eq!(time.speed_multiplier(), 1.0);
         assert_eq!(time.time_since_startup(), Duration::from_secs(0));
+        assert_eq!(time.real_time_since_startup(), Duration::from_secs(0));
 
         // Update `time` and check results.
         // The first update to `time` normally happens before other systems have run,
@@ -235,10 +274,18 @@ mod tests {
         );
 
         // Sanity check.
+        assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(first_update_instant));
         assert_eq!(time.startup(), start_instant);
         assert_eq!(time.speed_multiplier(), 1.0);
-        assert_eq!(time.time_since_startup(), Duration::from_secs(0));
+        assert_eq!(
+            time.time_since_startup(),
+            first_update_instant - start_instant
+        );
+        assert_eq!(
+            time.real_time_since_startup(),
+            first_update_instant - start_instant
+        );
 
         // Update `time` again and check results.
         // At this point its safe to use time.delta().
@@ -259,6 +306,7 @@ mod tests {
         );
 
         // Sanity check.
+        assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(second_update_instant));
         assert_eq!(time.startup(), start_instant);
         assert_eq!(time.speed_multiplier(), 1.0);
@@ -266,6 +314,10 @@ mod tests {
             time.time_since_startup(),
             second_update_instant - start_instant
         );
+        assert_eq!(
+            time.real_time_since_startup(),
+            second_update_instant - start_instant
+        );
 
         // Make app time advance at 2x the rate of real world time.
         time.set_speed_multiplier(2.0);
@@ -288,6 +340,7 @@ mod tests {
         );
 
         // Sanity check.
+        assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(third_update_instant));
         assert_eq!(time.startup(), start_instant);
 
@@ -297,5 +350,9 @@ mod tests {
             time.time_since_startup(),
             second_update_instant - start_instant + Duration::from_secs(2)
         );
+        assert_eq!(
+            time.real_time_since_startup(),
+            second_update_instant - start_instant + Duration::from_secs(1)
+        );
     }
 }

From 4d5b0e40e6a19dd617973f8eb2c8db336f614434 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sat, 23 Oct 2021 08:13:46 -0700
Subject: [PATCH 12/27] edit comments

---
 crates/bevy_core/src/time/time.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 423fe7c2079029..4b43aa41fca77d 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -3,7 +3,7 @@ use bevy_utils::{Duration, Instant};
 
 use crate::FixedTimestepState;
 
-/// Tracks time elapsed since the previous update and total frame time since the app was started.
+/// Tracks time elapsed since the previous update and since the app was started.
 #[derive(Debug, Clone)]
 pub struct Time {
     delta: Duration,
@@ -109,21 +109,19 @@ impl Time {
         self.fixed_delta_seconds_f64 = self.fixed_delta.as_secs_f64();
     }
 
-    /// The rate that app time advances relative to true clock time, as [`f32`].
-    /// Mainly used with the built-in fixed timestep.
+    /// The rate that time advances relative to the real world, as [`f32`].
     #[inline]
     pub fn speed_multiplier(&self) -> f32 {
         self.speed_multiplier
     }
 
-    /// The rate that app time advances relative to true clock time, as [`f64`].
-    /// Mainly used with the built-in fixed timestep.
+    /// The rate that time advances relative to the real world, as [`f64`].
     #[inline]
     pub fn speed_multiplier_f64(&self) -> f64 {
         self.speed_multiplier as f64
     }
 
-    /// Set rate app time advances relative to true clock time. Must be >= 0.0.
+    /// Set rate time advances relative to the real world. Must be >= 0.0.
     #[inline]
     pub fn set_speed_multiplier(&mut self, speed_multiplier: f32) {
         assert!(speed_multiplier >= 0.0);
@@ -150,6 +148,7 @@ impl Time {
 
     /// The time since startup, as [`Duration`]. Affected by speed multiplier.
     /// Sampled during the latest update.
+    #[inline]
     pub fn time_since_startup(&self) -> Duration {
         self.time_since_startup
     }

From f357dfb362eed443a7492b5ea2fbd0e19898fb33 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Tue, 26 Oct 2021 14:59:35 -0700
Subject: [PATCH 13/27] bikeshed

---
 crates/bevy_core/src/time/time.rs | 36 +++++++++++++++----------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 4b43aa41fca77d..d6e133e0433bb9 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -12,7 +12,7 @@ pub struct Time {
     fixed_delta: Duration,
     fixed_delta_seconds: f32,
     fixed_delta_seconds_f64: f64,
-    speed_multiplier: f32,
+    relative_speed: f32,
     time_since_startup: Duration,
     first_update: Option<Instant>,
     last_update: Option<Instant>,
@@ -31,7 +31,7 @@ impl Default for Time {
             fixed_delta,
             fixed_delta_seconds: fixed_delta.as_secs_f32(),
             fixed_delta_seconds_f64: fixed_delta.as_secs_f64(),
-            speed_multiplier: 1.0,
+            relative_speed: 1.0,
             time_since_startup: Duration::from_secs(0),
             first_update: None,
             last_update: None,
@@ -51,10 +51,10 @@ impl Time {
             self.delta = instant - last_update;
             self.delta_seconds = self.delta.as_secs_f32();
             self.delta_seconds_f64 = self.delta.as_secs_f64();
-            self.time_since_startup += self.delta.mul_f32(self.speed_multiplier);
+            self.time_since_startup += self.delta.mul_f32(self.relative_speed);
         } else {
             self.first_update = Some(instant);
-            self.time_since_startup += (instant - self.startup).mul_f32(self.speed_multiplier);
+            self.time_since_startup += (instant - self.startup).mul_f32(self.relative_speed);
         }
 
         self.last_update = Some(instant);
@@ -101,7 +101,7 @@ impl Time {
 
     /// Changes [`Time::fixed_delta`]. Users are strongly cautioned against modifying
     /// the step rate this way, except during startup.
-    /// Prefer [`Time::set_speed_multiplier`] to ensure that consumers of
+    /// Prefer [`Time::set_relative_speed`] to ensure that consumers of
     /// [`Time::fixed_delta`] produce consistent behavior.
     pub fn set_steps_per_second(&mut self, steps: f32) {
         self.fixed_delta = Duration::from_secs_f32(1.0 / steps);
@@ -111,21 +111,21 @@ impl Time {
 
     /// The rate that time advances relative to the real world, as [`f32`].
     #[inline]
-    pub fn speed_multiplier(&self) -> f32 {
-        self.speed_multiplier
+    pub fn relative_speed(&self) -> f32 {
+        self.relative_speed
     }
 
     /// The rate that time advances relative to the real world, as [`f64`].
     #[inline]
-    pub fn speed_multiplier_f64(&self) -> f64 {
-        self.speed_multiplier as f64
+    pub fn relative_speed_f64(&self) -> f64 {
+        self.relative_speed as f64
     }
 
     /// Set rate time advances relative to the real world. Must be >= 0.0.
     #[inline]
-    pub fn set_speed_multiplier(&mut self, speed_multiplier: f32) {
-        assert!(speed_multiplier >= 0.0);
-        self.speed_multiplier = speed_multiplier;
+    pub fn set_relative_speed(&mut self, relative_speed: f32) {
+        assert!(relative_speed >= 0.0);
+        self.relative_speed = relative_speed;
     }
 
     /// The ['Instant'] when [`Time::update`] was first called, if it exists.
@@ -211,7 +211,7 @@ impl Time {
 pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) {
     time.update();
     accumulator.add_time(
-        time.delta().mul_f32(time.speed_multiplier()),
+        time.delta().mul_f32(time.relative_speed()),
         time.fixed_delta(),
     );
 }
@@ -249,7 +249,7 @@ mod tests {
         assert_eq!(time.first_update(), None);
         assert_eq!(time.last_update(), None);
         assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.speed_multiplier(), 1.0);
+        assert_eq!(time.relative_speed(), 1.0);
         assert_eq!(time.time_since_startup(), Duration::from_secs(0));
         assert_eq!(time.real_time_since_startup(), Duration::from_secs(0));
 
@@ -276,7 +276,7 @@ mod tests {
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(first_update_instant));
         assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.speed_multiplier(), 1.0);
+        assert_eq!(time.relative_speed(), 1.0);
         assert_eq!(
             time.time_since_startup(),
             first_update_instant - start_instant
@@ -308,7 +308,7 @@ mod tests {
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(second_update_instant));
         assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.speed_multiplier(), 1.0);
+        assert_eq!(time.relative_speed(), 1.0);
         assert_eq!(
             time.time_since_startup(),
             second_update_instant - start_instant
@@ -319,7 +319,7 @@ mod tests {
         );
 
         // Make app time advance at 2x the rate of real world time.
-        time.set_speed_multiplier(2.0);
+        time.set_relative_speed(2.0);
 
         // Update `time` again 1 second later.
         let third_update_instant = second_update_instant + Duration::from_secs(1);
@@ -344,7 +344,7 @@ mod tests {
         assert_eq!(time.startup(), start_instant);
 
         // App is advancing 2x real time speed, so app time should have advanced by 2 seconds.
-        assert_eq!(time.speed_multiplier(), 2.0);
+        assert_eq!(time.relative_speed(), 2.0);
         assert_eq!(
             time.time_since_startup(),
             second_update_instant - start_instant + Duration::from_secs(2)

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

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

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

From b32d19263ff886debb125885fdb7207091525517 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sat, 6 Nov 2021 15:27:28 -0700
Subject: [PATCH 15/27] me dum dum

---
 crates/bevy_core/src/time/time.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index a65642f584ceb4..a7e614c78211d3 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -75,10 +75,10 @@ impl Time {
 
             if self.relative_speed != 1.0 {
                 // just to be safe
-                self.elapsed_since_startup +=
+                self.elapsed_since_startup =
                     (instant - self.startup).mul_f64(self.relative_speed as f64);
             } else {
-                self.elapsed_since_startup += instant - self.startup;
+                self.elapsed_since_startup = instant - self.startup;
             }
         }
 

From 2ea1c847f405a62eea530573d91345acf2e0734c Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 16 Dec 2021 11:39:40 -0800
Subject: [PATCH 16/27] cache all values, add direct `set_fixed_delta` method,
 add asserts, refine doc comments

---
 crates/bevy_core/src/time/fixed_timestep.rs |  92 +++--
 crates/bevy_core/src/time/time.rs           | 375 +++++++++++---------
 2 files changed, 271 insertions(+), 196 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index b98cb392b88ac3..4a3f55367fde0a 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -2,82 +2,98 @@ use bevy_ecs::{schedule::ShouldRun, system::ResMut};
 use bevy_utils::Duration;
 
 use crate::Time;
-
 #[derive(Debug, Clone)]
 pub struct FixedTimestepState {
-    time: Duration,
     steps: u32,
+    overstep: Duration,
 }
 
 impl Default for FixedTimestepState {
     fn default() -> Self {
         Self {
-            time: Duration::ZERO,
             steps: 0,
+            overstep: Duration::ZERO,
         }
     }
 }
 
 impl FixedTimestepState {
-    pub fn new(time: Duration, steps: u32) -> Self {
-        Self { time, steps }
+    /// Constructs a new `FixedTimestepState`.
+    pub fn new(steps: u32, overstep: Duration) -> Self {
+        Self { steps, overstep }
     }
 
-    /// The number of accrued steps.
+    /// Returns the number of steps accumulated.
     #[inline]
     pub fn steps(&self) -> u32 {
         self.steps
     }
 
-    /// The amount of time accrued toward new steps as [`Duration`].
+    /// Returns the amount of time accumulated toward new steps, as a [`Duration`].
     #[inline]
-    pub fn time(&self) -> Duration {
-        self.time
-    }
-
-    pub fn set_steps(&mut self, steps: u32) {
-        self.steps = steps;
+    pub fn overstep(&self) -> Duration {
+        self.overstep
     }
 
-    pub fn set_time(&mut self, time: Duration) {
-        self.time = time;
-    }
-
-    /// The amount of time accrued toward the next step as [`f32`] % of timestep.
+    /// Returns the amount of time accumulated toward new steps, as an [`f32`] fraction of `timestep`.
+    ///
+    /// Use this function when interpolating data between two timesteps.
+    ///
+    /// # Panics
+    /// Panics if `timestep` is a zero-length duration.
     pub fn overstep_percentage(&self, timestep: Duration) -> f32 {
-        self.time.as_secs_f32() / timestep.as_secs_f32()
-    }
-
-    /// The amount of time accrued toward the next step as [`f64`] % of timestep.
-    pub fn overstep_percentage_f64(&self, timestep: Duration) -> f64 {
-        self.time.as_secs_f64() / timestep.as_secs_f64()
+        assert_ne!(timestep, Duration::ZERO);
+        self.overstep.as_secs_f32() / timestep.as_secs_f32()
     }
 
-    /// Add to the accrued time, then convert into as many steps as possible.
+    /// Adds `time` to the internal `overstep`, then converts the `overstep` accumulated into
+    /// as many steps of size `timestep` as possible.
+    ///
+    /// # Panics
+    /// Panics if `timestep` is a zero-length duration.
     pub fn add_time(&mut self, time: Duration, timestep: Duration) {
-        self.time += time;
-        while self.time >= timestep {
-            self.time -= timestep;
+        assert_ne!(timestep, Duration::ZERO);
+        self.overstep += time;
+        while self.overstep >= timestep {
+            self.overstep -= timestep;
             self.steps += 1;
         }
     }
 
-    /// Consume a stored step (if any).
+    /// 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
     }
 
+    /// Resets everything accumulated to zero.
     pub fn reset(&mut self) {
-        self.time = Duration::ZERO;
         self.steps = 0;
+        self.overstep = Duration::ZERO;
+    }
+
+    #[inline]
+    pub fn set_steps(&mut self, steps: u32) {
+        self.steps = steps;
+    }
+
+    #[inline]
+    pub fn set_overstep(&mut self, overstep: Duration) {
+        self.overstep = overstep;
     }
 }
 
+/// Runs once for every [`Time::fixed_delta`] seconds advanced.
+///
+/// That does **not** mean "once every `Time::fixed_delta` seconds."
+/// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
 pub struct FixedTimestep;
 
 impl FixedTimestep {
+    /// Returns `ShouldRun::YesAndCheckAgain` if there were accumulated steps remaining.
+    /// Returns `ShouldRun::No` otherwise.
     pub fn step(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) -> ShouldRun {
         if accumulator.sub_step().is_some() {
             time.advance_step();
@@ -98,38 +114,38 @@ mod tests {
         let mut accumulator = FixedTimestepState::default();
 
         assert_eq!(accumulator.steps(), 0);
-        assert_eq!(accumulator.time(), Duration::ZERO);
+        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.time(), Duration::ZERO);
+        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.time(), Duration::ZERO);
+        assert_eq!(accumulator.overstep(), Duration::ZERO);
 
-        accumulator.set_time(Duration::from_secs(1));
+        accumulator.set_overstep(Duration::from_secs(1));
 
         assert_eq!(accumulator.steps(), 4);
-        assert_eq!(accumulator.time(), Duration::from_secs(1));
+        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
 
         accumulator.set_steps(12);
 
         assert_eq!(accumulator.steps(), 12);
-        assert_eq!(accumulator.time(), Duration::from_secs(1));
+        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
 
         accumulator.reset();
 
         assert_eq!(accumulator.steps(), 0);
-        assert_eq!(accumulator.time(), Duration::ZERO);
+        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.time(), Duration::ZERO);
+        assert_eq!(accumulator.overstep(), Duration::ZERO);
     }
 }
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index a7e614c78211d3..a983c24fb254f6 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -6,49 +6,64 @@ use crate::FixedTimestepState;
 /// Tracks time elapsed since the previous update and since the app was started.
 #[derive(Debug, Clone)]
 pub struct Time {
+    startup: Instant,
+    first_update: Option<Instant>,
+    last_update: Option<Instant>,
+    relative_speed: f32,
     delta: Duration,
     delta_seconds: f32,
     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,
-    relative_speed: f32,
-    elapsed_since_startup: Duration,
-    first_update: Option<Instant>,
-    last_update: Option<Instant>,
-    startup: Instant,
+    raw_elapsed_since_startup: Duration,
+    raw_seconds_since_startup: f32,
+    raw_seconds_since_startup_f64: f64,
     fixed_delta: Duration,
     fixed_delta_seconds: f32,
     fixed_delta_seconds_f64: f64,
     fixed_elapsed_since_startup: Duration,
+    fixed_seconds_since_startup: f32,
+    fixed_seconds_since_startup_f64: f64,
 }
 
 impl Default for Time {
     fn default() -> Self {
-        // 60Hz is a popular number, but it can't be expressed as an exact float.
+        // 60Hz is a popular tick rate, but it can't be expressed as an exact float.
         // Powers of two (i.e. 32Hz, 64Hz, 128Hz) are better for numerical integration.
         let fixed_delta = Duration::from_secs_f32(1.0 / 64.0);
         Self {
+            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,
+            seconds_since_startup_f64: 0.0,
             raw_delta: Duration::ZERO,
             raw_delta_seconds: 0.0,
             raw_delta_seconds_f64: 0.0,
-            relative_speed: 1.0,
-            elapsed_since_startup: Duration::ZERO,
-            first_update: None,
-            last_update: None,
-            startup: Instant::now(),
+            raw_elapsed_since_startup: Duration::ZERO,
+            raw_seconds_since_startup: 0.0,
+            raw_seconds_since_startup_f64: 0.0,
             fixed_delta,
             fixed_delta_seconds: fixed_delta.as_secs_f32(),
             fixed_delta_seconds_f64: fixed_delta.as_secs_f64(),
             fixed_elapsed_since_startup: Duration::ZERO,
+            fixed_seconds_since_startup: 0.0,
+            fixed_seconds_since_startup_f64: 0.0,
         }
     }
 }
 
 impl Time {
+    /// Updates the internal time measurements.
     pub fn update(&mut self) {
         let now = Instant::now();
         self.update_with_instant(now);
@@ -60,224 +75,278 @@ impl Time {
             self.raw_delta_seconds = self.raw_delta.as_secs_f32();
             self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
 
-            if self.relative_speed != 1.0 {
-                // just to be safe
-                self.delta = self.raw_delta.mul_f64(self.relative_speed_f64());
+            self.raw_elapsed_since_startup = instant - self.startup;
+            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();
+            
+            // avoid rounding errors when speed is 1:1
+            self.delta = if self.relative_speed != 1.0 {
+                self.raw_delta.mul_f64(self.relative_speed as f64)
             } else {
-                self.delta = self.raw_delta;
-            }
-
+                self.raw_delta
+            };
             self.delta_seconds = self.delta.as_secs_f32();
             self.delta_seconds_f64 = self.delta.as_secs_f64();
+            
             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();
+
         } else {
             self.first_update = Some(instant);
+            let raw_delta = instant - self.startup;
 
-            if self.relative_speed != 1.0 {
-                // just to be safe
-                self.elapsed_since_startup =
-                    (instant - self.startup).mul_f64(self.relative_speed as 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();
+
+            // avoid rounding errors when speed is 1:1
+            let delta = if self.relative_speed != 1.0 {
+                raw_delta.mul_f64(self.relative_speed as f64)
             } else {
-                self.elapsed_since_startup = instant - self.startup;
-            }
+                raw_delta
+            };
+
+            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.last_update = Some(instant);
     }
 
-    pub(crate) fn advance_step(&mut self) {
-        self.fixed_elapsed_since_startup += self.fixed_delta;
+    /// Returns the [`Instant`] the app was started.
+    #[inline]
+    pub fn startup(&self) -> Instant {
+        self.startup
     }
 
-    /// The time since the last update, as a [`Duration`].
-    /// Affected by [`Time::relative_speed`].
+    /// Returns the [`Instant`] when [`Time::update`] was first called, if it exists.
     #[inline]
-    pub fn delta(&self) -> Duration {
-        self.delta
+    pub fn first_update(&self) -> Option<Instant> {
+        self.first_update
     }
 
-    /// The time since the last update, as [`f32`] seconds.
-    /// Affected by [`Time::relative_speed`].
+    /// Returns the [`Instant`] when [`Time::update`] was last called, if it exists.
     #[inline]
-    pub fn delta_seconds(&self) -> f32 {
-        self.delta_seconds
+    pub fn last_update(&self) -> Option<Instant> {
+        self.last_update
     }
 
-    /// The time since the last update, as [`f64`] seconds.
-    /// Affected by [`Time::relative_speed`].
+    /// Returns the rate that time advances relative to raw CPU time, as [`f32`].
+    ///
+    /// 1:1 by default.
     #[inline]
-    pub fn delta_seconds_f64(&self) -> f64 {
-        self.delta_seconds_f64
+    pub fn relative_speed(&self) -> f32 {
+        self.relative_speed
     }
 
-    /// The exact CPU time since the last update, as a [`Duration`].
-    /// **Not** affected by [`Time::relative_speed`].
+    /// Sets the rate that time advances relative to raw CPU time.
+    ///
+    /// # Panics
+    /// Panics if `rate` is not finite or negative.
     #[inline]
-    pub fn raw_delta(&self) -> Duration {
-        self.raw_delta
+    pub fn set_relative_speed(&mut self, relative_speed: f32) {
+        assert!(relative_speed.is_sign_positive() && relative_speed.is_finite());
+        self.relative_speed = relative_speed;
     }
 
-    /// The exact CPU time since the last update, as [`f32`] seconds.
-    /// **Not** affected by [`Time::relative_speed`].
+    /// Returns how much time advanced since the last update, as a [`Duration`].
     #[inline]
-    pub fn raw_delta_seconds(&self) -> f32 {
-        self.raw_delta_seconds
+    pub fn delta(&self) -> Duration {
+        self.delta
     }
 
-    /// The exact CPU time since the last update, as [`f64`] seconds.
-    /// **Not** affected by [`Time::relative_speed`].
+    /// Returns how much time advanced since the last update, as [`f32`] seconds.
     #[inline]
-    pub fn raw_delta_seconds_f64(&self) -> f64 {
-        self.raw_delta_seconds_f64
+    pub fn delta_seconds(&self) -> f32 {
+        self.delta_seconds
     }
 
-    /// The reciprocal of the rate set by [`Time::set_steps_per_second`], as a [`Duration`].
-    ///
-    /// A fixed timestep only guarantees that N steps run for each second of elapsed time, not that
-    /// one step runs every [`Time::fixed_delta`] seconds. The exact CPU time between steps depends
-    /// on the frame rate, so use [`Time::fixed_delta`] in systems for consistent behavior.
+    /// Returns how much time advanced since the last update, as [`f64`] seconds.
     #[inline]
-    pub fn fixed_delta(&self) -> Duration {
-        self.fixed_delta
+    pub fn delta_seconds_f64(&self) -> f64 {
+        self.delta_seconds_f64
     }
 
-    /// The reciprocal of the rate set by [`Time::set_steps_per_second`], as [`f32`] seconds.
-    ///
-    /// A fixed timestep only guarantees that N steps run for each second of elapsed time, not that
-    /// one step runs every [`Time::fixed_delta`] seconds. The exact CPU time between steps depends
-    /// on the frame rate, so use [`Time::fixed_delta`] in systems for consistent behavior.
+    /// Returns how much time has advanced since startup, as [`Duration`].
     #[inline]
-    pub fn fixed_delta_seconds(&self) -> f32 {
-        self.fixed_delta_seconds
+    pub fn elapsed_since_startup(&self) -> Duration {
+        self.elapsed_since_startup
     }
 
-    /// The reciprocal of the rate set by [`Time::set_steps_per_second`], as [`f64`] seconds.
-    ///
-    /// A fixed timestep only guarantees that N steps run for each second of elapsed time, not that
-    /// one step runs every [`Time::fixed_delta`] seconds. The exact CPU time between steps depends
-    /// on the frame rate, so use [`Time::fixed_delta`] in systems for consistent behavior.
+    /// Returns how much time has advanced since startup, as [`f32`] seconds.
     #[inline]
-    pub fn fixed_delta_seconds_f64(&self) -> f64 {
-        self.fixed_delta_seconds_f64
+    pub fn seconds_since_startup(&self) -> f32 {
+        self.seconds_since_startup
     }
 
-    /// Change the step Hz (changes [`Time::fixed_delta`]). Users are strongly cautioned against
-    /// changing this outside of startup. Use [`Time::set_relative_speed`] to ensure that systems
-    /// using [`fixed_delta`] behave consistently.
-    pub fn set_steps_per_second(&mut self, rate: f32) {
-        self.fixed_delta = Duration::from_secs_f32(1.0 / rate);
-        self.fixed_delta_seconds = self.fixed_delta.as_secs_f32();
-        self.fixed_delta_seconds_f64 = self.fixed_delta.as_secs_f64();
+    /// Returns how much time has advanced since startup, as [`f64`] seconds.
+    #[inline]
+    pub fn seconds_since_startup_f64(&self) -> f64 {
+        self.seconds_since_startup_f64
     }
 
-    /// The rate that time advances relative to CPU time, as [`f32`]. 1.0 by default.
+    /// Returns the exact CPU time elapsed since the last update, as a [`Duration`].
+    ///
+    /// This quantity is **not** affected by [`Time::relative_speed`].
     #[inline]
-    pub fn relative_speed(&self) -> f32 {
-        self.relative_speed
+    pub fn raw_delta(&self) -> Duration {
+        self.raw_delta
     }
 
-    /// The rate that time advances relative to CPU time, as [`f64`]. 1.0 by default.
+    /// Returns the exact CPU time elapsed since the last update, as [`f32`] seconds.
+    ///
+    /// This quantity is **not** affected by [`Time::relative_speed`].
     #[inline]
-    pub fn relative_speed_f64(&self) -> f64 {
-        self.relative_speed as f64
+    pub fn raw_delta_seconds(&self) -> f32 {
+        self.raw_delta_seconds
     }
 
-    /// Set the rate that time advances relative to CPU time. Must be >= 0.0.
+    /// Returns the exact CPU time elapsed since the last update, as [`f64`] seconds.
+    ///
+    /// This quantity is **not** affected by [`Time::relative_speed`].
     #[inline]
-    pub fn set_relative_speed(&mut self, relative_speed: f32) {
-        assert!((relative_speed >= 0.0) && relative_speed.is_finite());
-        self.relative_speed = relative_speed;
+    pub fn raw_delta_seconds_f64(&self) -> f64 {
+        self.raw_delta_seconds_f64
     }
 
-    /// The [`Instant`] when [`Time::update`] was first called, if it exists.
-    #[inline]
-    pub fn first_update(&self) -> Option<Instant> {
-        self.first_update
+    /// Returns the exact CPU time elapsed since startup, as [`Duration`].
+    pub fn raw_elapsed_since_startup(&self) -> Duration {
+        self.raw_elapsed_since_startup
     }
 
-    /// The [`Instant`] when [`Time::update`] was last called, if it exists.
+    /// Returns the exact CPU time elapsed since startup, as [`f32`] seconds.
     #[inline]
-    pub fn last_update(&self) -> Option<Instant> {
-        self.last_update
+    pub fn raw_seconds_since_startup(&self) -> f32 {
+        self.raw_seconds_since_startup
     }
 
-    /// The [`Instant`] the app was started.
+    /// Returns the exact CPU time elapsed since startup, as [`f64`] seconds.
     #[inline]
-    pub fn startup(&self) -> Instant {
-        self.startup
+    pub fn raw_seconds_since_startup_f64(&self) -> f64 {
+        self.raw_seconds_since_startup_f64
     }
 
-    /// The time since startup, as [`Duration`].
-    /// Advances by [`Time::delta`] each update.
+    /// Returns how much fixed time advances in each fixed update, as a [`Duration`].
+    ///
+    /// Use this in systems running with [`FixedTimestep`] criteria to ensure consistent behavior.
+    ///
+    /// `FixedTimestep` will run once *for* every `Time::fixed_delta`
+    /// seconds advanced, not once every `Time::fixed_delta` seconds.
+    /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
     #[inline]
-    pub fn elapsed_since_startup(&self) -> Duration {
-        self.elapsed_since_startup
+    pub fn fixed_delta(&self) -> Duration {
+        self.fixed_delta
     }
 
-    /// The time since startup, as [`f32`] seconds.
-    /// Advances by [`Time::delta`] each update.
+    /// Returns how much fixed time advances in each fixed update, as [`f32`] seconds.
+    ///
+    /// Use this in systems running with [`FixedTimestep`] criteria to ensure consistent behavior.
+    ///
+    /// `FixedTimestep` will run once *for* every `Time::fixed_delta`
+    /// seconds advanced, not once every `Time::fixed_delta` seconds.
+    /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
     #[inline]
-    pub fn seconds_since_startup(&self) -> f32 {
-        self.elapsed_since_startup().as_secs_f32()
+    pub fn fixed_delta_seconds(&self) -> f32 {
+        self.fixed_delta_seconds
     }
 
-    /// The time since startup, as [`f64`] seconds.
-    /// Advances by [`Time::delta`] each update.
+    /// Returns how much fixed time advances in each fixed update, as [`f64`] seconds.
+    ///
+    /// Use this in systems running with [`FixedTimestep`] criteria to ensure consistent behavior.
+    ///
+    /// `FixedTimestep` will run once *for* every `Time::fixed_delta`
+    /// seconds advanced, not once every `Time::fixed_delta` seconds.
+    /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
     #[inline]
-    pub fn seconds_since_startup_f64(&self) -> f64 {
-        self.elapsed_since_startup().as_secs_f64()
+    pub fn fixed_delta_seconds_f64(&self) -> f64 {
+        self.fixed_delta_seconds_f64
     }
 
-    /// The exact CPU time since startup, as [`Duration`].
-    /// Advances by [`Time::raw_delta`] each update.
-    pub fn raw_elapsed_since_startup(&self) -> Duration {
-        self.last_update.unwrap_or(self.startup) - self.startup
+    /// Returns the nominal fixed update rate (reciprocal of [`Time::fixed_delta`]) as `f32`.
+    pub fn steps_per_second(&self) -> f32 {
+        1.0 / self.fixed_delta_seconds
     }
 
-    /// The exact CPU time since startup, as [`f32`] seconds.
-    /// Advances by [`Time::raw_delta`] each update.
-    #[inline]
-    pub fn raw_seconds_since_startup(&self) -> f32 {
-        self.raw_elapsed_since_startup().as_secs_f32()
+    /// Sets [`Time::fixed_delta`] to `delta`.
+    ///
+    /// This will affect the behavior of systems reading `Time::fixed_delta`, so users
+    /// are strongly cautioned against modifying it outside of startup.
+    ///
+    /// Use [`Time::set_relative_speed`] to temporarily adjust the step rate while
+    /// preserving consistent behavior.
+    ///
+    /// # Panics
+    /// Panics if `delta` is a zero-length duration.
+    pub fn set_fixed_delta(&mut self, delta: Duration) {
+        assert_ne!(delta, Duration::ZERO);
+        self.delta = delta;
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
     }
 
-    /// The exact CPU time since startup, as [`f64`] seconds.
-    /// Advances by [`Time::raw_delta`] each update.
-    #[inline]
-    pub fn raw_seconds_since_startup_f64(&self) -> f64 {
-        self.raw_elapsed_since_startup().as_secs_f64()
+    /// Sets [`Time::fixed_delta`] to the reciprocal of `rate`.
+    ///
+    /// This will affect the behavior of systems reading `Time::fixed_delta`, so users
+    /// are strongly cautioned against modifying it outside of startup.
+    ///
+    /// Use [`Time::set_relative_speed`] to temporarily adjust the step rate while
+    /// preserving consistent behavior.
+    ///
+    /// # Panics
+    /// Panics if `rate` is not finite or less than or equal to zero.
+    pub fn set_steps_per_second(&mut self, rate: f32) {
+        assert!(rate > 0.0 && rate.is_finite());
+        self.set_fixed_delta(Duration::from_secs_f32(1.0 / rate));
     }
 
-    /// The time since startup, as [`Duration`].
-    /// Advances by [`Time::fixed_delta`] each step.
+    /// Returns how much fixed time has advanced since startup, as [`Duration`].
+    ///
+    /// This follows [`Time::elapsed_since_startup`] but advances in whole increments of
+    /// [`Time::fixed_delta`].
     #[inline]
     pub fn fixed_elapsed_since_startup(&self) -> Duration {
-        // NOTE: actually lags behind time.elapsed_since_startup()
-        // because time.first_update() - time.startup() isn't counted
         self.fixed_elapsed_since_startup
     }
 
-    /// The time since startup, as [`f32`] seconds.
-    /// Advances by [`Time::fixed_delta`] each step.
+    /// Returns how much fixed time has advanced since startup, as [`f32`] seconds.
+    ///
+    /// This follows [`Time::elapsed_since_startup`] but advances in whole increments of
+    /// [`Time::fixed_delta`].
     #[inline]
     pub fn fixed_seconds_since_startup(&self) -> f32 {
-        self.fixed_elapsed_since_startup().as_secs_f32()
+        self.fixed_seconds_since_startup
     }
 
-    /// The time since startup, as [`f64`] seconds.
-    /// Advances by [`Time::fixed_delta`] each step.
+    /// Returns how much fixed time has advanced since startup, as [`f64`] seconds.
+    ///
+    /// This follows [`Time::elapsed_since_startup`] but advances in whole increments of
+    /// [`Time::fixed_delta`].
     #[inline]
     pub fn fixed_seconds_since_startup_f64(&self) -> f64 {
-        self.fixed_elapsed_since_startup().as_secs_f64()
+        self.fixed_seconds_since_startup_f64
+    }
+
+    /// Advance fixed time by one step's worth of time.
+    pub(crate) fn advance_step(&mut self) {
+        self.fixed_elapsed_since_startup += self.fixed_delta;
+        self.fixed_seconds_since_startup = self.fixed_elapsed_since_startup.as_secs_f32();
+        self.fixed_seconds_since_startup_f64 = self.fixed_elapsed_since_startup.as_secs_f64();
     }
 }
 
 pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) {
-    time.update();
-    accumulator.add_time(
-        time.delta().mul_f64(time.relative_speed_f64()),
-        time.fixed_delta(),
-    );
+    let now = Instant::now();
+    let first = time.last_update().is_none();
+    time.update_with_instant(now);
+    // accumulate startup delay on first update
+    let mut delta = if first { now - time.startup() } else { time.delta() };
+    // avoid rounding errors when speed is 1:1
+    if time.relative_speed() != 1.0 {
+        delta = delta.mul_f64(time.relative_speed() as f64);
+    }
+    accumulator.add_time(delta, time.fixed_delta());
 }
 
 #[cfg(test)]
@@ -300,10 +369,8 @@ mod tests {
         // Ensure `time` was constructed correctly.
         assert_eq!(time.raw_delta(), Duration::ZERO);
         assert_eq!(time.raw_delta_seconds(), 0.0);
-        assert_eq!(time.raw_delta_seconds_f64(), 0.0);
         assert_eq!(time.delta(), Duration::ZERO);
         assert_eq!(time.delta_seconds(), 0.0);
-        assert_eq!(time.delta_seconds_f64(), 0.0);
         assert_eq!(time.first_update(), None);
         assert_eq!(time.last_update(), None);
         assert_eq!(time.startup(), start_instant);
@@ -319,10 +386,8 @@ mod tests {
 
         assert_eq!(time.raw_delta(), Duration::ZERO);
         assert_eq!(time.raw_delta_seconds(), 0.0);
-        assert_eq!(time.raw_delta_seconds_f64(), 0.0);
         assert_eq!(time.delta(), Duration::ZERO);
         assert_eq!(time.delta_seconds(), 0.0);
-        assert_eq!(time.delta_seconds_f64(), 0.0);
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(first_update_instant));
         assert_eq!(time.startup(), start_instant);
@@ -346,10 +411,8 @@ mod tests {
             second_update_instant - first_update_instant
         );
         assert_eq!(time.raw_delta_seconds(), time.raw_delta().as_secs_f32());
-        assert_eq!(time.raw_delta_seconds_f64(), time.raw_delta().as_secs_f64());
         assert_eq!(time.delta(), second_update_instant - first_update_instant);
         assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
-        assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(second_update_instant));
         assert_eq!(time.startup(), start_instant);
@@ -375,10 +438,8 @@ mod tests {
         assert_eq!(time.relative_speed(), 2.0);
         assert_eq!(time.raw_delta(), elapsed);
         assert_eq!(time.raw_delta_seconds(), time.raw_delta().as_secs_f32());
-        assert_eq!(time.raw_delta_seconds_f64(), time.raw_delta().as_secs_f64());
         assert_eq!(time.delta(), elapsed.mul_f32(2.0));
         assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
-        assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(third_update_instant));
         assert_eq!(time.startup(), start_instant);
@@ -404,18 +465,22 @@ mod tests {
 
         let fixed_delta = time.fixed_delta();
 
-        // Create a `FixedTimestep for testing.
-        let mut accumulator = FixedTimestepState::new(Duration::ZERO, 0);
+        // Create a `FixedTimestepState` for testing.
+        let mut accumulator = FixedTimestepState::new(0, Duration::ZERO);
 
         // Get the first update out of the way, so that
         // time.delta() will get a nonzero value next time.
         let first_update_instant = Instant::now();
+        let startup_delay = first_update_instant - start_instant;
         time.update_with_instant(first_update_instant);
+        accumulator.add_time(
+            startup_delay.mul_f64(time.relative_speed() as f64),
+            time.fixed_delta(),
+        );
 
         // Confirm that fixed delta didn't change on its own.
         assert_eq!(time.fixed_delta(), fixed_delta);
         assert_eq!(time.fixed_delta_seconds(), fixed_delta.as_secs_f32());
-        assert_eq!(time.fixed_delta_seconds_f64(), fixed_delta.as_secs_f64());
 
         // Run for 10.5x the timestep.
         let ten = time.fixed_delta() * 10;
@@ -423,7 +488,7 @@ mod tests {
         let second_update_instant = first_update_instant + ten + half;
         time.update_with_instant(second_update_instant);
         accumulator.add_time(
-            time.delta().mul_f64(time.relative_speed_f64()),
+            time.delta().mul_f64(time.relative_speed() as f64),
             time.fixed_delta(),
         );
 
@@ -431,17 +496,13 @@ mod tests {
         assert_eq!(time.raw_delta(), ten + half);
         assert_eq!(time.delta(), time.raw_delta());
         assert_eq!(accumulator.steps(), 10);
-        assert_eq!(accumulator.time(), half);
+        assert_eq!(accumulator.overstep(), half + startup_delay);
 
         assert_eq!(time.fixed_elapsed_since_startup(), Duration::ZERO);
         assert_eq!(
             time.fixed_seconds_since_startup(),
             Duration::ZERO.as_secs_f32()
         );
-        assert_eq!(
-            time.fixed_seconds_since_startup_f64(),
-            Duration::ZERO.as_secs_f64()
-        );
 
         // Consume accumulated steps and advanced the fixed time clock.
         while accumulator.sub_step().is_some() {
@@ -451,16 +512,14 @@ mod tests {
         // Confirm that fixed delta didn't change on its own.
         assert_eq!(time.fixed_delta(), fixed_delta);
         assert_eq!(time.fixed_delta_seconds(), fixed_delta.as_secs_f32());
-        assert_eq!(time.fixed_delta_seconds_f64(), fixed_delta.as_secs_f64());
 
         // Confirm that the fixed time clock has advanced 10 steps worth of time.
         assert_eq!(time.fixed_elapsed_since_startup(), ten);
         assert_eq!(time.fixed_seconds_since_startup(), ten.as_secs_f32());
-        assert_eq!(time.fixed_seconds_since_startup_f64(), ten.as_secs_f64());
 
         // Confirm that the fixed clock lags behind the normal clock by a specific amount.
         let diff = time.elapsed_since_startup() - time.fixed_elapsed_since_startup();
-        let expected = time.first_update().unwrap() - time.startup() + accumulator.time();
+        let expected = accumulator.overstep();
         assert_eq!(diff, expected);
     }
 }

From e0335c2229ba8e5e0be28c9c41c41e515ee0b63a Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sun, 9 Jan 2022 13:40:44 -0800
Subject: [PATCH 17/27] updated diagnostics plugins to use raw time
 measurements

---
 crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs | 5 +++--
 crates/bevy_diagnostic/src/log_diagnostics_plugin.rs        | 4 ++--
 examples/ui/text_debug.rs                                   | 2 +-
 examples/wasm/winit_wasm.rs                                 | 4 ++--
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
index 2ff6f17af4f803..06f9ecba2c5c02 100644
--- a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
@@ -40,11 +40,12 @@ impl FrameTimeDiagnosticsPlugin {
         state.frame_count += 1.0;
         diagnostics.add_measurement(Self::FRAME_COUNT, state.frame_count);
 
-        if time.delta_seconds_f64() == 0.0 {
+        let frame_time = time.raw_delta_seconds_f64();
+        if frame_time == 0.0 {
             return;
         }
 
-        diagnostics.add_measurement(Self::FRAME_TIME, time.delta_seconds_f64());
+        diagnostics.add_measurement(Self::FRAME_TIME, frame_time);
         if let Some(fps) = diagnostics
             .get(Self::FRAME_TIME)
             .and_then(|frame_time_diagnostic| {
diff --git a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
index 571b050a1d877b..8f2a9c478aaf18 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().map(|id| diagnostics.get(*id).unwrap()) {
                     Self::log_diagnostic(diagnostic);
@@ -103,7 +103,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().map(|id| diagnostics.get(*id).unwrap()) {
                     debug!("{:#?}\n", diagnostic);
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index b5c062b47d0029..c32aabaea48aef 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -184,7 +184,7 @@ fn change_text_system(
             }
         }
 
-        let mut frame_time = time.delta_seconds_f64();
+        let mut frame_time = time.raw_delta_seconds_f64();
         if let Some(frame_time_diagnostic) = diagnostics.get(FrameTimeDiagnosticsPlugin::FRAME_TIME)
         {
             if let Some(frame_time_avg) = frame_time_diagnostic.average() {
diff --git a/examples/wasm/winit_wasm.rs b/examples/wasm/winit_wasm.rs
index 08010dafd3ed1a..2ed51b859cc079 100644
--- a/examples/wasm/winit_wasm.rs
+++ b/examples/wasm/winit_wasm.rs
@@ -32,8 +32,8 @@ fn counter(mut state: Local<CounterState>, time: Res<Time>) {
         info!(
             "tick {} @ {:?} [Δ{}]",
             state.count,
-            time.elapsed_since_startup(),
-            time.delta_seconds()
+            time.raw_elapsed_since_startup(),
+            time.raw_delta_seconds()
         );
     }
     state.count += 1;

From cce75d9f9491a0e69cb9587614b590ec510ffd8c Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 3 Mar 2022 20:15:21 -0800
Subject: [PATCH 18/27] fix differences

---
 crates/bevy_core/src/lib.rs                 |  23 +-
 crates/bevy_core/src/time/fixed_timestep.rs | 338 ++++++++++++--
 crates/bevy_core/src/time/time.rs           | 463 ++++++++------------
 examples/3d/spawner.rs                      |  74 ----
 examples/ecs/fixed_timestep.rs              |  15 +-
 examples/ecs/iter_combinations.rs           |  99 +++--
 examples/ecs/state.rs                       |  75 +---
 examples/game/alien_cake_addict.rs          |  38 +-
 examples/game/breakout.rs                   | 318 ++++++++++++++
 examples/shader/animate_shader.rs           | 318 ++++++++++----
 examples/tools/bevymark.rs                  | 155 ++++---
 examples/wasm/winit_wasm.rs                 |  89 ----
 12 files changed, 1238 insertions(+), 767 deletions(-)
 delete mode 100644 examples/3d/spawner.rs
 delete mode 100644 examples/wasm/winit_wasm.rs

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 340779901486a5..2b5d7943da60bd 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -1,21 +1,22 @@
-mod bytes;
+#![warn(missing_docs)]
+//! This crate provides core functionality for Bevy Engine.
+
 mod float_ord;
-mod label;
 mod name;
 mod task_pool_options;
 mod time;
 
-pub use bytes::*;
+pub use bytemuck::{bytes_of, cast_slice, Pod, Zeroable};
 pub use float_ord::*;
-pub use label::*;
 pub use name::*;
 pub use task_pool_options::DefaultTaskPoolOptions;
 pub use time::*;
 
 pub mod prelude {
+    //! The Bevy Core Prelude.
     #[doc(hidden)]
     pub use crate::{
-        DefaultTaskPoolOptions, EntityLabels, FixedTimestep, Labels, Name, Time, Timer,
+        DefaultTaskPoolOptions, FixedTime, FixedTimestep, FixedTimestepState, Name, Time, Timer,
     };
 }
 
@@ -32,10 +33,11 @@ use std::ops::Range;
 #[derive(Default)]
 pub struct CorePlugin;
 
+/// A `SystemLabel` enum for ordering systems relative to core Bevy systems.
 #[derive(Debug, PartialEq, Eq, Clone, Hash, SystemLabel)]
 pub enum CoreSystem {
-    /// Updates the elapsed time.
-    /// Any system interacting with the [`Time`] resource should run after this.
+    /// Updates the elapsed time. Any system that interacts with [Time] component should run after
+    /// this.
     Time,
 }
 
@@ -49,13 +51,12 @@ impl Plugin for CorePlugin {
             .create_default_pools(&mut app.world);
 
         app.init_resource::<Time>()
+            .init_resource::<FixedTime>()
             .init_resource::<FixedTimestepState>()
-            .init_resource::<EntityLabels>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
             .register_type::<Entity>()
             .register_type::<Name>()
-            .register_type::<Labels>()
             .register_type::<Range<f32>>()
             .register_type::<Timer>()
             // time system is added as an "exclusive system" to ensure it runs before other systems
@@ -63,9 +64,7 @@ impl Plugin for CorePlugin {
             .add_system_to_stage(
                 CoreStage::First,
                 time_system.exclusive_system().label(CoreSystem::Time),
-            )
-            .add_startup_system_to_stage(StartupStage::PostStartup, entity_labels_system)
-            .add_system_to_stage(CoreStage::PostUpdate, entity_labels_system);
+            );
 
         register_rust_types(app);
         register_math_types(app);
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 4a3f55367fde0a..1b9c6ea46c5f02 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -1,7 +1,190 @@
 use bevy_ecs::{schedule::ShouldRun, system::ResMut};
-use bevy_utils::Duration;
+use bevy_utils::{Duration, Instant};
 
-use crate::Time;
+/// `FixedTime` tracks how much time has advanced since its previous update and since an app was started.
+///
+/// It's just like [`Time`](super::time::Time) (and internally coupled to it), except it updates in fixed increments.
+#[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 Default for FixedTime {
+    fn default() -> Self {
+        // 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.
+        let delta = Duration::from_micros(15625); // 64Hz
+        Self {
+            startup: Instant::now(),
+            first_update: None,
+            last_update: None,
+            delta,
+            delta_seconds: delta.as_secs_f32(),
+            delta_seconds_f64: delta.as_secs_f64(),
+            elapsed_since_startup: Duration::ZERO,
+            seconds_since_startup: 0.0,
+            seconds_since_startup_f64: 0.0,
+        }
+    }
+}
+
+impl FixedTime {
+    /// Constructs a new `FixedTime` instance with a specific timestep [`Duration`] and startup [`Instant`].
+    pub fn new(delta: Duration, startup: Instant) -> Self {
+        Self {
+            startup,
+            delta,
+            delta_seconds: delta.as_secs_f32(),
+            delta_seconds_f64: delta.as_secs_f64(),
+            ..Default::default()
+        }
+    }
+
+    /// Updates internal time measurements.
+    pub fn update(&mut self) {
+        self.update_with_instant(Instant::now());
+    }
+
+    /// Advances fixed time by the fixed delta and records the [`Instant`] it happened.
+    pub(crate) 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();
+    }
+
+    /// Returns the [`Instant`] the app was started.
+    #[inline]
+    pub fn startup(&self) -> Instant {
+        self.startup
+    }
+
+    /// Returns the [`Instant`] when [`FixedTime::update`] was first called, if it exists.
+    #[inline]
+    pub fn first_update(&self) -> Option<Instant> {
+        self.first_update
+    }
+
+    /// Returns the [`Instant`] when [`FixedTime::update`] was last called, if it exists.
+    #[inline]
+    pub fn last_update(&self) -> Option<Instant> {
+        self.last_update
+    }
+
+    /// Returns how much fixed time advances in each update, as a [`Duration`].
+    #[inline]
+    pub fn delta(&self) -> Duration {
+        self.delta
+    }
+
+    /// Returns how much fixed time advances in each update, as [`f32`] seconds.
+    #[inline]
+    pub fn delta_seconds(&self) -> f32 {
+        self.delta_seconds
+    }
+
+    /// Returns how much fixed time advances in each update, as [`f64`] seconds.
+    #[inline]
+    pub fn delta_seconds_f64(&self) -> f64 {
+        self.delta_seconds_f64
+    }
+
+    /// Sets the timestep to `delta`, given as [`Duration`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `delta` is a zero-length duration.
+    #[inline]
+    pub fn set_delta(&mut self, delta: Duration) {
+        assert_ne!(delta, Duration::ZERO);
+        self.delta = delta;
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
+    }
+
+    /// Sets the timestep to `delta`, given as [`f32`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `delta` is less than or equal to zero, not finite, or overflows the `Duration`.
+    pub fn set_delta_f32(&mut self, delta: f32) {
+        self.set_delta(Duration::from_secs_f32(delta));
+    }
+
+    /// Sets the timestep to `delta`, given as [`f64`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `delta` is less than or equal to zero, not finite, or overflows the `Duration`.
+    pub fn set_delta_f64(&mut self, delta: f64) {
+        self.set_delta(Duration::from_secs_f64(delta));
+    }
+
+    /// Returns the nominal fixed update rate (reciprocal of [`FixedTime::delta`]) as [`f32`].
+    #[inline]
+    pub fn steps_per_second(&self) -> f32 {
+        1.0 / self.delta_seconds
+    }
+
+    /// Returns the nominal fixed update rate (reciprocal of [`FixedTime::delta`]) as [`f64`].
+    #[inline]
+    pub fn steps_per_second_f64(&self) -> f64 {
+        1.0 / self.delta_seconds_f64
+    }
+
+    /// Sets the timestep to the reciprocal of `rate`, given as [`f32`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `rate` is less than or equal to zero or not finite.
+    #[inline]
+    pub fn set_steps_per_second(&mut self, rate: f32) {
+        assert!(rate > 0.0 && rate.is_finite());
+        self.set_delta(Duration::from_secs_f32(1.0 / rate));
+    }
+
+    /// Sets the timestep to the reciprocal of `rate`, given as [`f64`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `rate` is less than or equal to zero or not finite.
+    #[inline]
+    pub fn set_steps_per_second_f64(&mut self, rate: f64) {
+        assert!(rate > 0.0 && rate.is_finite());
+        self.set_delta(Duration::from_secs_f64(1.0 / rate));
+    }
+
+    /// Returns how much fixed time has advanced since startup, as [`Duration`].
+    #[inline]
+    pub fn elapsed_since_startup(&self) -> Duration {
+        self.elapsed_since_startup
+    }
+
+    /// Returns how much fixed time has advanced since startup, as [`f32`] seconds.
+    #[inline]
+    pub fn seconds_since_startup(&self) -> f32 {
+        self.seconds_since_startup
+    }
+
+    /// Returns how much fixed time has advanced since startup, as [`f64`] seconds.
+    #[inline]
+    pub fn seconds_since_startup_f64(&self) -> f64 {
+        self.seconds_since_startup_f64
+    }
+}
+
+/// Accumulates time and converts it into steps: one step per `timestep` accumulated.
 #[derive(Debug, Clone)]
 pub struct FixedTimestepState {
     steps: u32,
@@ -40,16 +223,30 @@ impl FixedTimestepState {
     /// Use this function when interpolating data between two timesteps.
     ///
     /// # Panics
+    ///
     /// Panics if `timestep` is a zero-length duration.
     pub fn overstep_percentage(&self, timestep: Duration) -> f32 {
         assert_ne!(timestep, Duration::ZERO);
         self.overstep.as_secs_f32() / timestep.as_secs_f32()
     }
 
+    /// Returns the amount of time accumulated toward new steps, as an [`f64`] fraction of `timestep`.
+    ///
+    /// Use this function when interpolating data between two timesteps.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `timestep` is a zero-length duration.
+    pub fn overstep_percentage_f64(&self, timestep: Duration) -> f64 {
+        assert_ne!(timestep, Duration::ZERO);
+        self.overstep.as_secs_f64() / timestep.as_secs_f64()
+    }
+
     /// Adds `time` to the internal `overstep`, then converts the `overstep` accumulated into
     /// as many steps of size `timestep` as possible.
     ///
     /// # Panics
+    ///
     /// Panics if `timestep` is a zero-length duration.
     pub fn add_time(&mut self, time: Duration, timestep: Duration) {
         assert_ne!(timestep, Duration::ZERO);
@@ -68,84 +265,141 @@ impl FixedTimestepState {
         remaining
     }
 
-    /// Resets everything accumulated to zero.
+    /// Clears accumulated time and steps.
+    #[inline]
     pub fn reset(&mut self) {
         self.steps = 0;
         self.overstep = Duration::ZERO;
     }
-
-    #[inline]
-    pub fn set_steps(&mut self, steps: u32) {
-        self.steps = steps;
-    }
-
-    #[inline]
-    pub fn set_overstep(&mut self, overstep: Duration) {
-        self.overstep = overstep;
-    }
 }
 
-/// Runs once for every [`Time::fixed_delta`] seconds advanced.
+/// A run criteria that enables a stage (or lone system) to run once per [`FixedTime::delta`] seconds advanced.
 ///
-/// That does **not** mean "once every `Time::fixed_delta` seconds."
+/// That does **not** mean "once every `FixedTime::delta` seconds."
 /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
+///
+/// For example, a [`Stage`](bevy_ecs::schedule::Stage) set to run 60 steps per second will run once for every 16.7ms that [`Time`] advances,
+/// but unless [`Time::delta`] is always exactly 16.7ms, the actual measured time between steps will vary
+/// (the _average_ should be 16.7ms). Thus, for consistent behavior, users should avoid [`Time`] in the systems with this run criteria and use [`FixedTime`] instead.
 pub struct FixedTimestep;
 
 impl FixedTimestep {
-    /// Returns `ShouldRun::YesAndCheckAgain` if there were accumulated steps remaining.
-    /// Returns `ShouldRun::No` otherwise.
-    pub fn step(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) -> ShouldRun {
-        if accumulator.sub_step().is_some() {
-            time.advance_step();
-            ShouldRun::YesAndCheckAgain
-        } else {
-            ShouldRun::No
+    /// 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,
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::FixedTimestepState;
-    use bevy_utils::Duration;
-
+    use crate::{FixedTime, FixedTimestepState, Time};
+    use bevy_utils::{Duration, Instant};
     #[test]
-    fn test_methods() {
+    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.set_overstep(Duration::from_secs(1));
-
-        assert_eq!(accumulator.steps(), 4);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
-
-        accumulator.set_steps(12);
-
-        assert_eq!(accumulator.steps(), 12);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
-
         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);
     }
+
+    #[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()
+        );
+
+        // 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_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index a983c24fb254f6..2b968eeb736db2 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -1,15 +1,12 @@
-use bevy_ecs::system::ResMut;
 use bevy_utils::{Duration, Instant};
 
-use crate::FixedTimestepState;
-
-/// Tracks time elapsed since the previous update and since the app was started.
+/// `Time` tracks how much time has advanced (and also the raw CPU time elapsed) since its previous update and since an app was started.
 #[derive(Debug, Clone)]
 pub struct Time {
     startup: Instant,
     first_update: Option<Instant>,
     last_update: Option<Instant>,
-    relative_speed: f32,
+    relative_speed: f64, // using `f64` instead of `f32` to minimize drift from rounding errors
     delta: Duration,
     delta_seconds: f32,
     delta_seconds_f64: f64,
@@ -22,19 +19,10 @@ pub struct Time {
     raw_elapsed_since_startup: Duration,
     raw_seconds_since_startup: f32,
     raw_seconds_since_startup_f64: f64,
-    fixed_delta: Duration,
-    fixed_delta_seconds: f32,
-    fixed_delta_seconds_f64: f64,
-    fixed_elapsed_since_startup: Duration,
-    fixed_seconds_since_startup: f32,
-    fixed_seconds_since_startup_f64: f64,
 }
 
 impl Default for Time {
     fn default() -> Self {
-        // 60Hz is a popular tick rate, but it can't be expressed as an exact float.
-        // Powers of two (i.e. 32Hz, 64Hz, 128Hz) are better for numerical integration.
-        let fixed_delta = Duration::from_secs_f32(1.0 / 64.0);
         Self {
             startup: Instant::now(),
             first_update: None,
@@ -52,57 +40,55 @@ impl Default for Time {
             raw_elapsed_since_startup: Duration::ZERO,
             raw_seconds_since_startup: 0.0,
             raw_seconds_since_startup_f64: 0.0,
-            fixed_delta,
-            fixed_delta_seconds: fixed_delta.as_secs_f32(),
-            fixed_delta_seconds_f64: fixed_delta.as_secs_f64(),
-            fixed_elapsed_since_startup: Duration::ZERO,
-            fixed_seconds_since_startup: 0.0,
-            fixed_seconds_since_startup_f64: 0.0,
         }
     }
 }
 
 impl Time {
+    /// Constructs a new `Time` instance with a specific startup time.
+    pub fn new(startup: Instant) -> Self {
+        Self {
+            startup,
+            ..Default::default()
+        }
+    }
+
     /// Updates the internal time measurements.
     pub fn update(&mut self) {
         let now = Instant::now();
         self.update_with_instant(now);
     }
 
+    /// Advances time and records the [`Instant`] it happened.
     pub(crate) fn update_with_instant(&mut self, instant: Instant) {
         if let Some(last_update) = self.last_update {
             self.raw_delta = instant - last_update;
-            self.raw_delta_seconds = self.raw_delta.as_secs_f32();
-            self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
-
             self.raw_elapsed_since_startup = instant - self.startup;
             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();
-            
-            // avoid rounding errors when speed is 1:1
+
+            // avoid any rounding errors when speed is 1:1
             self.delta = if self.relative_speed != 1.0 {
-                self.raw_delta.mul_f64(self.relative_speed as f64)
+                self.raw_delta.mul_f64(self.relative_speed)
             } else {
                 self.raw_delta
             };
             self.delta_seconds = self.delta.as_secs_f32();
             self.delta_seconds_f64 = self.delta.as_secs_f64();
-            
+
             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();
-
         } else {
             self.first_update = Some(instant);
-            let raw_delta = instant - self.startup;
 
-            self.raw_elapsed_since_startup = raw_delta;
+            let raw_delta = instant - self.startup;
             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();
 
-            // avoid rounding errors when speed is 1:1
+            // avoid any rounding errors when speed is 1:1
             let delta = if self.relative_speed != 1.0 {
-                raw_delta.mul_f64(self.relative_speed as f64)
+                raw_delta.mul_f64(self.relative_speed)
             } else {
                 raw_delta
             };
@@ -135,295 +121,261 @@ impl Time {
 
     /// Returns the rate that time advances relative to raw CPU time, as [`f32`].
     ///
-    /// 1:1 by default.
+    /// `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.
+    /// Sets the rate that time advances relative to raw CPU time, given as [`f32`].
     ///
     /// # Panics
-    /// Panics if `rate` is not finite or negative.
+    ///
+    /// Panics if `rate` negative or not finite.
     #[inline]
     pub fn set_relative_speed(&mut self, relative_speed: f32) {
+        assert!(relative_speed.is_sign_positive() && relative_speed.is_finite());
+        self.relative_speed = relative_speed as f64;
+    }
+
+    /// Sets the rate that time advances relative to raw CPU time, given as [`f64`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `rate` negative or not finite.
+    #[inline]
+    pub fn set_relative_speed_f64(&mut self, relative_speed: f64) {
         assert!(relative_speed.is_sign_positive() && relative_speed.is_finite());
         self.relative_speed = relative_speed;
     }
 
-    /// Returns how much time advanced since the last update, as a [`Duration`].
+    /// Returns how much time has advanced since the last update, as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
         self.delta
     }
 
-    /// Returns how much time advanced since the last update, as [`f32`] seconds.
+    /// Returns how much time has advanced since the last update, as [`f32`] seconds.
     #[inline]
     pub fn delta_seconds(&self) -> f32 {
         self.delta_seconds
     }
 
-    /// Returns how much time advanced since the last update, as [`f64`] seconds.
+    /// Returns how much time has advanced since the last update, as [`f64`] seconds.
     #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
         self.delta_seconds_f64
     }
 
-    /// Returns how much time has advanced since startup, as [`Duration`].
-    #[inline]
-    pub fn elapsed_since_startup(&self) -> Duration {
-        self.elapsed_since_startup
-    }
-
-    /// Returns how much time has advanced since startup, as [`f32`] seconds.
-    #[inline]
-    pub fn seconds_since_startup(&self) -> f32 {
-        self.seconds_since_startup
-    }
-
-    /// Returns how much time has advanced since startup, as [`f64`] seconds.
-    #[inline]
-    pub fn seconds_since_startup_f64(&self) -> f64 {
-        self.seconds_since_startup_f64
-    }
-
     /// Returns the exact CPU time elapsed since the last update, as a [`Duration`].
-    ///
-    /// This quantity is **not** affected by [`Time::relative_speed`].
     #[inline]
     pub fn raw_delta(&self) -> Duration {
         self.raw_delta
     }
 
     /// Returns the exact CPU time elapsed since the last update, as [`f32`] seconds.
-    ///
-    /// This quantity is **not** affected by [`Time::relative_speed`].
     #[inline]
     pub fn raw_delta_seconds(&self) -> f32 {
         self.raw_delta_seconds
     }
 
     /// Returns the exact CPU time elapsed since the last update, as [`f64`] seconds.
-    ///
-    /// This quantity is **not** affected by [`Time::relative_speed`].
     #[inline]
     pub fn raw_delta_seconds_f64(&self) -> f64 {
         self.raw_delta_seconds_f64
     }
 
-    /// Returns the exact CPU time elapsed since startup, as [`Duration`].
-    pub fn raw_elapsed_since_startup(&self) -> Duration {
-        self.raw_elapsed_since_startup
-    }
-
-    /// Returns the exact CPU time elapsed since startup, as [`f32`] seconds.
-    #[inline]
-    pub fn raw_seconds_since_startup(&self) -> f32 {
-        self.raw_seconds_since_startup
-    }
-
-    /// Returns the exact CPU time elapsed since startup, as [`f64`] seconds.
-    #[inline]
-    pub fn raw_seconds_since_startup_f64(&self) -> f64 {
-        self.raw_seconds_since_startup_f64
-    }
-
-    /// Returns how much fixed time advances in each fixed update, as a [`Duration`].
-    ///
-    /// Use this in systems running with [`FixedTimestep`] criteria to ensure consistent behavior.
-    ///
-    /// `FixedTimestep` will run once *for* every `Time::fixed_delta`
-    /// seconds advanced, not once every `Time::fixed_delta` seconds.
-    /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
+    /// Returns how much time has advanced since startup, as [`Duration`].
     #[inline]
-    pub fn fixed_delta(&self) -> Duration {
-        self.fixed_delta
+    pub fn elapsed_since_startup(&self) -> Duration {
+        self.elapsed_since_startup
     }
 
-    /// Returns how much fixed time advances in each fixed update, as [`f32`] seconds.
-    ///
-    /// Use this in systems running with [`FixedTimestep`] criteria to ensure consistent behavior.
-    ///
-    /// `FixedTimestep` will run once *for* every `Time::fixed_delta`
-    /// seconds advanced, not once every `Time::fixed_delta` seconds.
-    /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
+    /// Returns how much time has advanced since startup, as [`f32`] seconds.
     #[inline]
-    pub fn fixed_delta_seconds(&self) -> f32 {
-        self.fixed_delta_seconds
+    pub fn seconds_since_startup(&self) -> f32 {
+        self.seconds_since_startup
     }
 
-    /// Returns how much fixed time advances in each fixed update, as [`f64`] seconds.
-    ///
-    /// Use this in systems running with [`FixedTimestep`] criteria to ensure consistent behavior.
-    ///
-    /// `FixedTimestep` will run once *for* every `Time::fixed_delta`
-    /// seconds advanced, not once every `Time::fixed_delta` seconds.
-    /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
+    /// Returns how much time has advanced since startup, as [`f64`] seconds.
     #[inline]
-    pub fn fixed_delta_seconds_f64(&self) -> f64 {
-        self.fixed_delta_seconds_f64
-    }
-
-    /// Returns the nominal fixed update rate (reciprocal of [`Time::fixed_delta`]) as `f32`.
-    pub fn steps_per_second(&self) -> f32 {
-        1.0 / self.fixed_delta_seconds
-    }
-
-    /// Sets [`Time::fixed_delta`] to `delta`.
-    ///
-    /// This will affect the behavior of systems reading `Time::fixed_delta`, so users
-    /// are strongly cautioned against modifying it outside of startup.
-    ///
-    /// Use [`Time::set_relative_speed`] to temporarily adjust the step rate while
-    /// preserving consistent behavior.
-    ///
-    /// # Panics
-    /// Panics if `delta` is a zero-length duration.
-    pub fn set_fixed_delta(&mut self, delta: Duration) {
-        assert_ne!(delta, Duration::ZERO);
-        self.delta = delta;
-        self.delta_seconds = self.delta.as_secs_f32();
-        self.delta_seconds_f64 = self.delta.as_secs_f64();
-    }
-
-    /// Sets [`Time::fixed_delta`] to the reciprocal of `rate`.
-    ///
-    /// This will affect the behavior of systems reading `Time::fixed_delta`, so users
-    /// are strongly cautioned against modifying it outside of startup.
-    ///
-    /// Use [`Time::set_relative_speed`] to temporarily adjust the step rate while
-    /// preserving consistent behavior.
-    ///
-    /// # Panics
-    /// Panics if `rate` is not finite or less than or equal to zero.
-    pub fn set_steps_per_second(&mut self, rate: f32) {
-        assert!(rate > 0.0 && rate.is_finite());
-        self.set_fixed_delta(Duration::from_secs_f32(1.0 / rate));
+    pub fn seconds_since_startup_f64(&self) -> f64 {
+        self.seconds_since_startup_f64
     }
 
-    /// Returns how much fixed time has advanced since startup, as [`Duration`].
-    ///
-    /// This follows [`Time::elapsed_since_startup`] but advances in whole increments of
-    /// [`Time::fixed_delta`].
+    /// Returns the exact CPU time elapsed since startup, as [`Duration`].
     #[inline]
-    pub fn fixed_elapsed_since_startup(&self) -> Duration {
-        self.fixed_elapsed_since_startup
+    pub fn raw_elapsed_since_startup(&self) -> Duration {
+        self.raw_elapsed_since_startup
     }
 
-    /// Returns how much fixed time has advanced since startup, as [`f32`] seconds.
-    ///
-    /// This follows [`Time::elapsed_since_startup`] but advances in whole increments of
-    /// [`Time::fixed_delta`].
+    /// Returns the exact CPU time elapsed since startup, as [`f32`] seconds.
     #[inline]
-    pub fn fixed_seconds_since_startup(&self) -> f32 {
-        self.fixed_seconds_since_startup
+    pub fn raw_seconds_since_startup(&self) -> f32 {
+        self.raw_seconds_since_startup
     }
 
-    /// Returns how much fixed time has advanced since startup, as [`f64`] seconds.
-    ///
-    /// This follows [`Time::elapsed_since_startup`] but advances in whole increments of
-    /// [`Time::fixed_delta`].
+    /// Returns the exact CPU time elapsed since startup, as [`f64`] seconds.
     #[inline]
-    pub fn fixed_seconds_since_startup_f64(&self) -> f64 {
-        self.fixed_seconds_since_startup_f64
-    }
-
-    /// Advance fixed time by one step's worth of time.
-    pub(crate) fn advance_step(&mut self) {
-        self.fixed_elapsed_since_startup += self.fixed_delta;
-        self.fixed_seconds_since_startup = self.fixed_elapsed_since_startup.as_secs_f32();
-        self.fixed_seconds_since_startup_f64 = self.fixed_elapsed_since_startup.as_secs_f64();
+    pub fn raw_seconds_since_startup_f64(&self) -> f64 {
+        self.raw_seconds_since_startup_f64
     }
 }
 
-pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) {
-    let now = Instant::now();
+use crate::{FixedTime, FixedTimestepState};
+use bevy_ecs::system::{Res, ResMut};
+pub(crate) fn time_system(
+    mut time: ResMut<Time>,
+    fixed_time: Option<Res<FixedTime>>,
+    accumulator: Option<ResMut<FixedTimestepState>>,
+) {
     let first = time.last_update().is_none();
+    let now = Instant::now();
     time.update_with_instant(now);
-    // accumulate startup delay on first update
-    let mut delta = if first { now - time.startup() } else { time.delta() };
-    // avoid rounding errors when speed is 1:1
-    if time.relative_speed() != 1.0 {
-        delta = delta.mul_f64(time.relative_speed() as f64);
+    if let (Some(fixed_time), Some(mut accumulator)) = (fixed_time, accumulator) {
+        // `time.delta()` is kept zero on the first update, so we need to calculate it manually
+        let mut delta = if first {
+            now - time.startup()
+        } else {
+            time.raw_delta()
+        };
+        // avoid any rounding errors when speed is 1:1
+        if time.relative_speed() != 1.0 {
+            delta = delta.mul_f64(time.relative_speed_f64());
+        }
+        // accumulate the elasped frame time
+        accumulator.add_time(delta, fixed_time.delta());
     }
-    accumulator.add_time(delta, time.fixed_delta());
 }
 
 #[cfg(test)]
 #[allow(clippy::float_cmp)]
 mod tests {
     use super::Time;
-    use crate::FixedTimestepState;
     use bevy_utils::{Duration, Instant};
-
     #[test]
     fn update_test() {
         let start_instant = Instant::now();
-
         // Create a `Time` for testing.
-        let mut time = Time {
-            startup: start_instant,
-            ..Default::default()
-        };
-
+        let mut time = Time::new(start_instant);
         // Ensure `time` was constructed correctly.
-        assert_eq!(time.raw_delta(), Duration::ZERO);
-        assert_eq!(time.raw_delta_seconds(), 0.0);
-        assert_eq!(time.delta(), Duration::ZERO);
-        assert_eq!(time.delta_seconds(), 0.0);
+        assert_eq!(time.startup(), start_instant);
         assert_eq!(time.first_update(), None);
         assert_eq!(time.last_update(), None);
-        assert_eq!(time.startup(), start_instant);
         assert_eq!(time.relative_speed(), 1.0);
+        assert_eq!(time.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.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.
         // 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.raw_delta(), Duration::ZERO);
-        assert_eq!(time.raw_delta_seconds(), 0.0);
-        assert_eq!(time.delta(), Duration::ZERO);
-        assert_eq!(time.delta_seconds(), 0.0);
+        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.startup(), start_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
+            first_update_instant - start_instant,
+        );
+        assert_eq!(
+            time.seconds_since_startup(),
+            (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
+            first_update_instant - start_instant,
+        );
+        assert_eq!(
+            time.raw_seconds_since_startup(),
+            (first_update_instant - start_instant).as_secs_f32(),
+        );
+        assert_eq!(
+            time.raw_seconds_since_startup_f64(),
+            (first_update_instant - start_instant).as_secs_f64(),
         );
 
         // Update `time` again and check results.
         // At this point its safe to use time.delta().
         let second_update_instant = Instant::now();
         time.update_with_instant(second_update_instant);
-
-        assert_eq!(
-            time.raw_delta(),
-            second_update_instant - first_update_instant
-        );
-        assert_eq!(time.raw_delta_seconds(), time.raw_delta().as_secs_f32());
-        assert_eq!(time.delta(), second_update_instant - first_update_instant);
-        assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
+        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.startup(), start_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
+            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
+            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.
@@ -432,94 +384,37 @@ mod tests {
         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.relative_speed(), 2.0);
-        assert_eq!(time.raw_delta(), elapsed);
-        assert_eq!(time.raw_delta_seconds(), time.raw_delta().as_secs_f32());
-        assert_eq!(time.delta(), elapsed.mul_f32(2.0));
-        assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
+        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.startup(), start_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)
+            second_update_instant - start_instant + elapsed.mul_f32(2.0),
         );
         assert_eq!(
-            time.raw_elapsed_since_startup(),
-            second_update_instant - start_instant + elapsed
+            time.seconds_since_startup(),
+            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f32(),
         );
-    }
-
-    #[test]
-    fn fixed_timestep_test() {
-        let start_instant = Instant::now();
-
-        // Create a `Time` for testing.
-        let mut time = Time {
-            startup: start_instant,
-            ..Default::default()
-        };
-
-        let fixed_delta = time.fixed_delta();
-
-        // Create a `FixedTimestepState` for testing.
-        let mut accumulator = FixedTimestepState::new(0, Duration::ZERO);
-
-        // Get the first update out of the way, so that
-        // time.delta() will get a nonzero value next time.
-        let first_update_instant = Instant::now();
-        let startup_delay = first_update_instant - start_instant;
-        time.update_with_instant(first_update_instant);
-        accumulator.add_time(
-            startup_delay.mul_f64(time.relative_speed() as f64),
-            time.fixed_delta(),
+        assert_eq!(
+            time.raw_elapsed_since_startup(),
+            second_update_instant - start_instant + elapsed,
         );
-
-        // Confirm that fixed delta didn't change on its own.
-        assert_eq!(time.fixed_delta(), fixed_delta);
-        assert_eq!(time.fixed_delta_seconds(), fixed_delta.as_secs_f32());
-
-        // Run for 10.5x the timestep.
-        let ten = time.fixed_delta() * 10;
-        let half = time.fixed_delta() / 2;
-        let second_update_instant = first_update_instant + ten + half;
-        time.update_with_instant(second_update_instant);
-        accumulator.add_time(
-            time.delta().mul_f64(time.relative_speed() as f64),
-            time.fixed_delta(),
+        assert_eq!(
+            time.raw_seconds_since_startup(),
+            (second_update_instant - start_instant + elapsed).as_secs_f32(),
         );
-
-        // Confirm that 10.5 steps have accumulated.
-        assert_eq!(time.raw_delta(), ten + half);
-        assert_eq!(time.delta(), time.raw_delta());
-        assert_eq!(accumulator.steps(), 10);
-        assert_eq!(accumulator.overstep(), half + startup_delay);
-
-        assert_eq!(time.fixed_elapsed_since_startup(), Duration::ZERO);
         assert_eq!(
-            time.fixed_seconds_since_startup(),
-            Duration::ZERO.as_secs_f32()
+            time.raw_seconds_since_startup_f64(),
+            (second_update_instant - start_instant + elapsed).as_secs_f64(),
         );
-
-        // Consume accumulated steps and advanced the fixed time clock.
-        while accumulator.sub_step().is_some() {
-            time.advance_step();
-        }
-
-        // Confirm that fixed delta didn't change on its own.
-        assert_eq!(time.fixed_delta(), fixed_delta);
-        assert_eq!(time.fixed_delta_seconds(), fixed_delta.as_secs_f32());
-
-        // Confirm that the fixed time clock has advanced 10 steps worth of time.
-        assert_eq!(time.fixed_elapsed_since_startup(), ten);
-        assert_eq!(time.fixed_seconds_since_startup(), ten.as_secs_f32());
-
-        // Confirm that the fixed clock lags behind the normal clock by a specific amount.
-        let diff = time.elapsed_since_startup() - time.fixed_elapsed_since_startup();
-        let expected = accumulator.overstep();
-        assert_eq!(diff, expected);
     }
 }
diff --git a/examples/3d/spawner.rs b/examples/3d/spawner.rs
deleted file mode 100644
index fecf9d22aad52f..00000000000000
--- a/examples/3d/spawner.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use bevy::{
-    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
-    prelude::*,
-};
-use rand::{rngs::StdRng, Rng, SeedableRng};
-
-/// This example spawns a large number of cubes, each with its own changing position and material
-/// This is intended to be a stress test of bevy's ability to render many objects with different
-/// properties For the best results, run it in release mode:
-/// ```bash
-/// cargo run --example spawner --release
-/// ```
-/// NOTE: Bevy still has a number of optimizations to do in this area. Expect the
-/// performance here to go way up in the future
-fn main() {
-    App::new()
-        .add_plugins(DefaultPlugins)
-        .add_plugin(FrameTimeDiagnosticsPlugin::default())
-        .add_plugin(LogDiagnosticsPlugin::default())
-        .add_startup_system(setup)
-        .add_system(move_cubes)
-        .run();
-}
-
-fn move_cubes(
-    time: Res<Time>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-    mut query: Query<(&mut Transform, &Handle<StandardMaterial>)>,
-) {
-    for (mut transform, material_handle) in query.iter_mut() {
-        let material = materials.get_mut(material_handle).unwrap();
-        transform.translation += Vec3::new(1.0, 0.0, 0.0) * time.delta_seconds();
-        material.base_color = Color::BLUE * Vec3::splat((3.0 * time.seconds_since_startup()).sin());
-    }
-}
-
-fn setup(
-    mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-) {
-    // light
-    commands.spawn_bundle(PointLightBundle {
-        transform: Transform::from_xyz(4.0, -4.0, 5.0),
-        ..Default::default()
-    });
-    // camera
-    commands.spawn_bundle(PerspectiveCameraBundle {
-        transform: Transform::from_xyz(0.0, 15.0, 150.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..Default::default()
-    });
-
-    let mut rng = StdRng::from_entropy();
-    let cube_handle = meshes.add(Mesh::from(shape::Cube { size: 1.0 }));
-    for _ in 0..10000 {
-        commands.spawn_bundle(PbrBundle {
-            mesh: cube_handle.clone(),
-            material: materials.add(StandardMaterial {
-                base_color: Color::rgb(
-                    rng.gen_range(0.0..1.0),
-                    rng.gen_range(0.0..1.0),
-                    rng.gen_range(0.0..1.0),
-                ),
-                ..Default::default()
-            }),
-            transform: Transform::from_xyz(
-                rng.gen_range(-50.0..50.0),
-                rng.gen_range(-50.0..50.0),
-                0.0,
-            ),
-            ..Default::default()
-        });
-    }
-}
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index 26d5429376db1d..be9b3c82eeb173 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -23,7 +23,7 @@ fn main() {
         .run();
 }
 
-fn set_fixed_timestep(mut time: ResMut<Time>) {
+fn set_fixed_timestep(mut time: ResMut<FixedTime>) {
     time.set_steps_per_second(10.0);
 }
 
@@ -35,19 +35,24 @@ fn frame_update(mut last_time: Local<f32>, time: Res<Time>) {
     *last_time = time.seconds_since_startup();
 }
 
-fn fixed_update(mut last_time: Local<f32>, time: Res<Time>, accumulator: Res<FixedTimestepState>) {
+fn fixed_update(
+    mut last_time: Local<f32>,
+    time: Res<Time>,
+    fixed_time: Res<FixedTime>,
+    accumulator: Res<FixedTimestepState>,
+) {
     info!(
         "time since last fixed_update: {}\n",
         time.seconds_since_startup() - *last_time
     );
-    info!("fixed timestep: {}\n", time.fixed_delta_seconds());
+    info!("fixed timestep: {}\n", fixed_time.delta_seconds());
     info!(
         "time accrued toward next fixed_update: {}\n",
         accumulator.overstep().as_secs_f32()
     );
     info!(
-        "time accrued toward next fixed_update (% of time.fixed_delta): {}",
-        accumulator.overstep_percentage(time.fixed_delta())
+        "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 375d6f9590139c..82ce70f648835e 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -1,13 +1,19 @@
-use bevy::{core::FixedTimestep, prelude::*};
+use bevy::{core::FixedTimestep, pbr::AmbientLight, prelude::*, render::camera::Camera};
 use rand::{thread_rng, Rng};
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 struct FixedUpdateStage;
 
+const DELTA_TIME: f32 = 0.01;
+
 fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
+        .insert_resource(AmbientLight {
+            brightness: 0.03,
+            ..default()
+        })
         .add_startup_system(set_fixed_timestep)
         .add_startup_system(generate_bodies)
         .add_stage_after(
@@ -18,15 +24,12 @@ fn main() {
                 .with_system(interact_bodies)
                 .with_system(integrate),
         )
+        .add_system(look_at_star)
+        .insert_resource(ClearColor(Color::BLACK))
         .run();
 }
 
-fn set_fixed_timestep(mut time: ResMut<Time>) {
-    time.set_steps_per_second(100.0);
-}
-
 const GRAVITY_CONSTANT: f32 = 0.001;
-const SOFTENING: f32 = 0.01;
 const NUM_BODIES: usize = 100;
 
 #[derive(Component, Default)]
@@ -35,6 +38,8 @@ struct Mass(f32);
 struct Acceleration(Vec3);
 #[derive(Component, Default)]
 struct LastPos(Vec3);
+#[derive(Component)]
+struct Star;
 
 #[derive(Bundle, Default)]
 struct BodyBundle {
@@ -45,9 +50,12 @@ struct BodyBundle {
     acceleration: Acceleration,
 }
 
+fn set_fixed_timestep(mut fixed_time: ResMut<FixedTime>) {
+    fixed_time.set_delta_f32(DELTA_TIME);
+}
+
 fn generate_bodies(
     mut commands: Commands,
-    time: Res<Time>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
@@ -56,14 +64,13 @@ fn generate_bodies(
         subdivisions: 3,
     }));
 
-    let pos_range = 1.0..15.0;
     let color_range = 0.5..1.0;
     let vel_range = -0.5..0.5;
 
     let mut rng = thread_rng();
     for _ in 0..NUM_BODIES {
-        let mass_value_cube_root: f32 = rng.gen_range(0.5..4.0);
-        let mass_value: f32 = mass_value_cube_root * mass_value_cube_root * mass_value_cube_root;
+        let radius: f32 = rng.gen_range(0.1..0.7);
+        let mass_value = radius.powi(3) * 10.;
 
         let position = Vec3::new(
             rng.gen_range(-1.0..1.0),
@@ -71,25 +78,26 @@ fn generate_bodies(
             rng.gen_range(-1.0..1.0),
         )
         .normalize()
-            * rng.gen_range(pos_range.clone());
+            * rng.gen_range(0.2f32..1.0).powf(1. / 3.)
+            * 15.;
 
         commands.spawn_bundle(BodyBundle {
             pbr: PbrBundle {
                 transform: Transform {
                     translation: position,
-                    scale: Vec3::splat(mass_value_cube_root * 0.1),
-                    ..Default::default()
+                    scale: Vec3::splat(radius),
+                    ..default()
                 },
                 mesh: mesh.clone(),
                 material: materials.add(
-                    Color::rgb_linear(
+                    Color::rgb(
                         rng.gen_range(color_range.clone()),
                         rng.gen_range(color_range.clone()),
                         rng.gen_range(color_range.clone()),
                     )
                     .into(),
                 ),
-                ..Default::default()
+                ..default()
             },
             mass: Mass(mass_value),
             acceleration: Acceleration(Vec3::ZERO),
@@ -99,36 +107,47 @@ fn generate_bodies(
                         rng.gen_range(vel_range.clone()),
                         rng.gen_range(vel_range.clone()),
                         rng.gen_range(vel_range.clone()),
-                    ) * time.fixed_delta_seconds(),
+                    ) * DELTA_TIME as f32,
             ),
         });
     }
 
     // add bigger "star" body in the center
+    let star_radius = 1.;
     commands
         .spawn_bundle(BodyBundle {
             pbr: PbrBundle {
-                transform: Transform {
-                    scale: Vec3::splat(0.5),
-                    ..Default::default()
-                },
+                transform: Transform::from_scale(Vec3::splat(star_radius)),
                 mesh: meshes.add(Mesh::from(shape::Icosphere {
                     radius: 1.0,
                     subdivisions: 5,
                 })),
-                material: materials.add((Color::ORANGE_RED * 10.0).into()),
-                ..Default::default()
+                material: materials.add(StandardMaterial {
+                    base_color: Color::ORANGE_RED,
+                    emissive: (Color::ORANGE_RED * 2.),
+                    ..default()
+                }),
+                ..default()
             },
-            mass: Mass(1000.0),
-            ..Default::default()
+            mass: Mass(500.0),
+            ..default()
         })
-        .insert(PointLight {
-            color: Color::ORANGE_RED,
-            ..Default::default()
+        .insert(Star)
+        .with_children(|p| {
+            p.spawn_bundle(PointLightBundle {
+                point_light: PointLight {
+                    color: Color::WHITE,
+                    intensity: 400.0,
+                    range: 100.0,
+                    radius: star_radius,
+                    ..default()
+                },
+                ..default()
+            });
         });
     commands.spawn_bundle(PerspectiveCameraBundle {
-        transform: Transform::from_xyz(0.0, 10.5, -20.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..Default::default()
+        transform: Transform::from_xyz(0.0, 10.5, -30.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..default()
     });
 }
 
@@ -140,15 +159,18 @@ fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)
         let delta = transform2.translation - transform1.translation;
         let distance_sq: f32 = delta.length_squared();
 
-        let f = GRAVITY_CONSTANT / (distance_sq * (distance_sq + SOFTENING).sqrt());
+        let f = GRAVITY_CONSTANT / distance_sq;
         let force_unit_mass = delta * f;
         acc1.0 += force_unit_mass * *m2;
         acc2.0 -= force_unit_mass * *m1;
     }
 }
 
-fn integrate(time: Res<Time>, mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>) {
-    let dt_sq = time.fixed_delta_seconds() * time.fixed_delta_seconds();
+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 query.iter_mut() {
         // verlet integration
         // x(t+dt) = 2x(t) - x(t-dt) + a(t)dt^2 + O(dt^4)
@@ -160,3 +182,16 @@ fn integrate(time: Res<Time>, mut query: Query<(&mut Acceleration, &mut Transfor
         transform.translation = new_pos;
     }
 }
+
+fn look_at_star(
+    mut camera: Query<&mut Transform, (With<Camera>, Without<Star>)>,
+    star: Query<&Transform, With<Star>>,
+) {
+    let mut camera = camera.single_mut();
+    let star = star.single();
+    let new_rotation = camera
+        .looking_at(star.translation, Vec3::Y)
+        .rotation
+        .lerp(camera.rotation, 0.1);
+    camera.rotation = new_rotation;
+}
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index 3a712c328040e4..60459096214b50 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -1,11 +1,10 @@
 use bevy::prelude::*;
 
-/// This example illustrates how to use States to control transitioning from a Menu state to an
-/// InGame state.
+/// This example illustrates how to use [`States`] to control transitioning from a `Menu` state to
+/// an `InGame` state.
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .init_resource::<ButtonMaterials>()
         .add_state(AppState::Menu)
         .add_system_set(SystemSet::on_enter(AppState::Menu).with_system(setup_menu))
         .add_system_set(SystemSet::on_update(AppState::Menu).with_system(menu))
@@ -29,11 +28,11 @@ struct MenuData {
     button_entity: Entity,
 }
 
-fn setup_menu(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    button_materials: Res<ButtonMaterials>,
-) {
+const NORMAL_BUTTON: Color = Color::rgb(0.15, 0.15, 0.15);
+const HOVERED_BUTTON: Color = Color::rgb(0.25, 0.25, 0.25);
+const PRESSED_BUTTON: Color = Color::rgb(0.35, 0.75, 0.35);
+
+fn setup_menu(mut commands: Commands, asset_server: Res<AssetServer>) {
     // ui camera
     commands.spawn_bundle(UiCameraBundle::default());
     let button_entity = commands
@@ -46,10 +45,10 @@ fn setup_menu(
                 justify_content: JustifyContent::Center,
                 // vertically center child text
                 align_items: AlignItems::Center,
-                ..Default::default()
+                ..default()
             },
-            material: button_materials.normal.clone(),
-            ..Default::default()
+            color: NORMAL_BUTTON.into(),
+            ..default()
         })
         .with_children(|parent| {
             parent.spawn_bundle(TextBundle {
@@ -62,7 +61,7 @@ fn setup_menu(
                     },
                     Default::default(),
                 ),
-                ..Default::default()
+                ..default()
             });
         })
         .id();
@@ -71,23 +70,22 @@ fn setup_menu(
 
 fn menu(
     mut state: ResMut<State<AppState>>,
-    button_materials: Res<ButtonMaterials>,
     mut interaction_query: Query<
-        (&Interaction, &mut Handle<ColorMaterial>),
+        (&Interaction, &mut UiColor),
         (Changed<Interaction>, With<Button>),
     >,
 ) {
-    for (interaction, mut material) in interaction_query.iter_mut() {
+    for (interaction, mut color) in interaction_query.iter_mut() {
         match *interaction {
             Interaction::Clicked => {
-                *material = button_materials.pressed.clone();
+                *color = PRESSED_BUTTON.into();
                 state.set(AppState::InGame).unwrap();
             }
             Interaction::Hovered => {
-                *material = button_materials.hovered.clone();
+                *color = HOVERED_BUTTON.into();
             }
             Interaction::None => {
-                *material = button_materials.normal.clone();
+                *color = NORMAL_BUTTON.into();
             }
         }
     }
@@ -97,16 +95,11 @@ fn cleanup_menu(mut commands: Commands, menu_data: Res<MenuData>) {
     commands.entity(menu_data.button_entity).despawn_recursive();
 }
 
-fn setup_game(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-) {
-    let texture_handle = asset_server.load("branding/icon.png");
+fn setup_game(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.spawn_bundle(OrthographicCameraBundle::new_2d());
     commands.spawn_bundle(SpriteBundle {
-        material: materials.add(texture_handle.into()),
-        ..Default::default()
+        texture: asset_server.load("branding/icon.png"),
+        ..default()
     });
 }
 
@@ -137,32 +130,10 @@ fn movement(
     }
 }
 
-fn change_color(
-    time: Res<Time>,
-    mut assets: ResMut<Assets<ColorMaterial>>,
-    query: Query<&Handle<ColorMaterial>, With<Sprite>>,
-) {
-    for handle in query.iter() {
-        let material = assets.get_mut(handle).unwrap();
-        material
+fn change_color(time: Res<Time>, mut query: Query<&mut Sprite>) {
+    for mut sprite in query.iter_mut() {
+        sprite
             .color
-            .set_b((time.seconds_since_startup() * 5.0).sin() + 2.0);
-    }
-}
-
-struct ButtonMaterials {
-    normal: Handle<ColorMaterial>,
-    hovered: Handle<ColorMaterial>,
-    pressed: Handle<ColorMaterial>,
-}
-
-impl FromWorld for ButtonMaterials {
-    fn from_world(world: &mut World) -> Self {
-        let mut materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
-        ButtonMaterials {
-            normal: materials.add(Color::rgb(0.15, 0.15, 0.15).into()),
-            hovered: materials.add(Color::rgb(0.25, 0.25, 0.25).into()),
-            pressed: materials.add(Color::rgb(0.35, 0.75, 0.35).into()),
-        }
+            .set_b((time.seconds_since_startup() * 0.5).sin() + 2.0);
     }
 }
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index 5c1ab209eabfd7..7b00c80c59819a 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -15,7 +15,7 @@ fn main() {
         .init_resource::<Game>()
         .add_plugins(DefaultPlugins)
         .add_state(GameState::Playing)
-        .add_startup_system(set_fixed_timestep)
+        .add_startup_system(setup_fixed_timestep)
         .add_startup_system(setup_cameras)
         .add_system_set(SystemSet::on_enter(GameState::Playing).with_system(setup))
         .add_system_set(
@@ -69,10 +69,6 @@ struct Game {
     camera_is_focus: Vec3,
 }
 
-fn set_fixed_timestep(mut time: ResMut<Time>) {
-    time.set_steps_per_second(0.2);
-}
-
 const BOARD_SIZE_I: usize = 14;
 const BOARD_SIZE_J: usize = 21;
 
@@ -82,6 +78,10 @@ const RESET_FOCUS: [f32; 3] = [
     BOARD_SIZE_J as f32 / 2.0 - 0.5,
 ];
 
+fn setup_fixed_timestep(mut fixed_time: ResMut<FixedTime>) {
+    fixed_time.set_delta_f32(5.0);
+}
+
 fn setup_cameras(mut commands: Commands, mut game: ResMut<Game>) {
     game.camera_should_focus = Vec3::from(RESET_FOCUS);
     game.camera_is_focus = game.camera_should_focus;
@@ -92,7 +92,7 @@ fn setup_cameras(mut commands: Commands, mut game: ResMut<Game>) {
             BOARD_SIZE_J as f32 / 2.0 - 0.5,
         )
         .looking_at(game.camera_is_focus, Vec3::Y),
-        ..Default::default()
+        ..default()
     });
     commands.spawn_bundle(UiCameraBundle::default());
 }
@@ -111,9 +111,9 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMu
             intensity: 3000.0,
             shadows_enabled: true,
             range: 30.0,
-            ..Default::default()
+            ..default()
         },
-        ..Default::default()
+        ..default()
     });
 
     // spawn the game board
@@ -148,7 +148,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMu
                     game.player.j as f32,
                 ),
                 rotation: Quat::from_rotation_y(-std::f32::consts::FRAC_PI_2),
-                ..Default::default()
+                ..default()
             }))
             .with_children(|cell| {
                 cell.spawn_scene(asset_server.load("models/AlienCake/alien.glb#Scene0"));
@@ -175,11 +175,11 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMu
             position: Rect {
                 top: Val::Px(5.0),
                 left: Val::Px(5.0),
-                ..Default::default()
+                ..default()
             },
-            ..Default::default()
+            ..default()
         },
-        ..Default::default()
+        ..default()
     });
 }
 
@@ -241,7 +241,7 @@ fn move_player(
                     game.player.j as f32,
                 ),
                 rotation: Quat::from_rotation_y(rotation),
-                ..Default::default()
+                ..default()
             };
         }
     }
@@ -345,10 +345,10 @@ fn spawn_bonus(
                         color: Color::rgb(1.0, 1.0, 0.0),
                         intensity: 1000.0,
                         range: 10.0,
-                        ..Default::default()
+                        ..default()
                     },
                     transform: Transform::from_xyz(0.0, 2.0, 0.0),
-                    ..Default::default()
+                    ..default()
                 });
                 children.spawn_scene(game.bonus.handle.clone());
             })
@@ -389,10 +389,10 @@ fn display_score(mut commands: Commands, asset_server: Res<AssetServer>, game: R
                 margin: Rect::all(Val::Auto),
                 justify_content: JustifyContent::Center,
                 align_items: AlignItems::Center,
-                ..Default::default()
+                ..default()
             },
             color: Color::NONE.into(),
-            ..Default::default()
+            ..default()
         })
         .with_children(|parent| {
             parent.spawn_bundle(TextBundle {
@@ -405,7 +405,7 @@ fn display_score(mut commands: Commands, asset_server: Res<AssetServer>, game: R
                     },
                     Default::default(),
                 ),
-                ..Default::default()
+                ..default()
             });
         });
-}
+}
\ No newline at end of file
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index d6261bc3199cf1..4ecb68c4045692 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -1,3 +1,321 @@
+use bevy::{
+    core::FixedTimestep,
+    prelude::*,
+    sprite::collide_aabb::{collide, Collision},
+};
+
+/// An implementation of the classic game "Breakout"
+const TIME_STEP: f32 = 1.0 / 60.0;
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(Scoreboard { score: 0 })
+        .insert_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
+        .add_startup_system(setup)
+        .add_system_set(
+            SystemSet::new()
+                .with_run_criteria(FixedTimestep::step)
+                .with_system(paddle_movement_system)
+                .with_system(ball_collision_system)
+                .with_system(ball_movement_system),
+        )
+        .add_system(scoreboard_system)
+        .add_system(bevy::input::system::exit_on_esc_system)
+        .run();
+}
+
+#[derive(Component)]
+struct Paddle {
+    speed: f32,
+}
+
+#[derive(Component)]
+struct Ball {
+    velocity: Vec3,
+}
+
+#[derive(Component)]
+enum Collider {
+    Solid,
+    Scorable,
+    Paddle,
+}
+
+struct Scoreboard {
+    score: usize,
+}
+
+fn setup(
+    mut commands: Commands,
+    mut fixed_time: ResMut<FixedTime>,
+    asset_server: Res<AssetServer>,
+) {
+    // Set fixed timestep
+    fixed_time.set_delta_f32(TIME_STEP);
+
+    // Add the game's entities to our world
+
+    // cameras
+    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
+    commands.spawn_bundle(UiCameraBundle::default());
+    // paddle
+    commands
+        .spawn_bundle(SpriteBundle {
+            transform: Transform {
+                translation: Vec3::new(0.0, -215.0, 0.0),
+                scale: Vec3::new(120.0, 30.0, 0.0),
+                ..default()
+            },
+            sprite: Sprite {
+                color: Color::rgb(0.5, 0.5, 1.0),
+                ..default()
+            },
+            ..default()
+        })
+        .insert(Paddle { speed: 500.0 })
+        .insert(Collider::Paddle);
+    // ball
+    commands
+        .spawn_bundle(SpriteBundle {
+            transform: Transform {
+                scale: Vec3::new(30.0, 30.0, 0.0),
+                translation: Vec3::new(0.0, -50.0, 1.0),
+                ..default()
+            },
+            sprite: Sprite {
+                color: Color::rgb(1.0, 0.5, 0.5),
+                ..default()
+            },
+            ..default()
+        })
+        .insert(Ball {
+            velocity: 400.0 * Vec3::new(0.5, -0.5, 0.0).normalize(),
+        });
+    // scoreboard
+    commands.spawn_bundle(TextBundle {
+        text: Text {
+            sections: vec![
+                TextSection {
+                    value: "Score: ".to_string(),
+                    style: TextStyle {
+                        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                        font_size: 40.0,
+                        color: Color::rgb(0.5, 0.5, 1.0),
+                    },
+                },
+                TextSection {
+                    value: "".to_string(),
+                    style: TextStyle {
+                        font: asset_server.load("fonts/FiraMono-Medium.ttf"),
+                        font_size: 40.0,
+                        color: Color::rgb(1.0, 0.5, 0.5),
+                    },
+                },
+            ],
+            ..default()
+        },
+        style: Style {
+            position_type: PositionType::Absolute,
+            position: Rect {
+                top: Val::Px(5.0),
+                left: Val::Px(5.0),
+                ..default()
+            },
+            ..default()
+        },
+        ..default()
+    });
+
+    // Add walls
+    let wall_color = Color::rgb(0.8, 0.8, 0.8);
+    let wall_thickness = 10.0;
+    let bounds = Vec2::new(900.0, 600.0);
+
+    // left
+    commands
+        .spawn_bundle(SpriteBundle {
+            transform: Transform {
+                translation: Vec3::new(-bounds.x / 2.0, 0.0, 0.0),
+                scale: Vec3::new(wall_thickness, bounds.y + wall_thickness, 1.0),
+                ..default()
+            },
+            sprite: Sprite {
+                color: wall_color,
+                ..default()
+            },
+            ..default()
+        })
+        .insert(Collider::Solid);
+    // right
+    commands
+        .spawn_bundle(SpriteBundle {
+            transform: Transform {
+                translation: Vec3::new(bounds.x / 2.0, 0.0, 0.0),
+                scale: Vec3::new(wall_thickness, bounds.y + wall_thickness, 1.0),
+                ..default()
+            },
+            sprite: Sprite {
+                color: wall_color,
+                ..default()
+            },
+            ..default()
+        })
+        .insert(Collider::Solid);
+    // bottom
+    commands
+        .spawn_bundle(SpriteBundle {
+            transform: Transform {
+                translation: Vec3::new(0.0, -bounds.y / 2.0, 0.0),
+                scale: Vec3::new(bounds.x + wall_thickness, wall_thickness, 1.0),
+                ..default()
+            },
+            sprite: Sprite {
+                color: wall_color,
+                ..default()
+            },
+            ..default()
+        })
+        .insert(Collider::Solid);
+    // top
+    commands
+        .spawn_bundle(SpriteBundle {
+            transform: Transform {
+                translation: Vec3::new(0.0, bounds.y / 2.0, 0.0),
+                scale: Vec3::new(bounds.x + wall_thickness, wall_thickness, 1.0),
+                ..default()
+            },
+            sprite: Sprite {
+                color: wall_color,
+                ..default()
+            },
+            ..default()
+        })
+        .insert(Collider::Solid);
+
+    // Add bricks
+    let brick_rows = 4;
+    let brick_columns = 5;
+    let brick_spacing = 20.0;
+    let brick_size = Vec3::new(150.0, 30.0, 1.0);
+    let bricks_width = brick_columns as f32 * (brick_size.x + brick_spacing) - brick_spacing;
+    // center the bricks and move them up a bit
+    let bricks_offset = Vec3::new(-(bricks_width - brick_size.x) / 2.0, 100.0, 0.0);
+    let brick_color = Color::rgb(0.5, 0.5, 1.0);
+    for row in 0..brick_rows {
+        let y_position = row as f32 * (brick_size.y + brick_spacing);
+        for column in 0..brick_columns {
+            let brick_position = Vec3::new(
+                column as f32 * (brick_size.x + brick_spacing),
+                y_position,
+                0.0,
+            ) + bricks_offset;
+            // brick
+            commands
+                .spawn_bundle(SpriteBundle {
+                    sprite: Sprite {
+                        color: brick_color,
+                        ..default()
+                    },
+                    transform: Transform {
+                        translation: brick_position,
+                        scale: brick_size,
+                        ..default()
+                    },
+                    ..default()
+                })
+                .insert(Collider::Scorable);
+        }
+    }
+}
+
+fn paddle_movement_system(
+    keyboard_input: Res<Input<KeyCode>>,
+    mut query: Query<(&Paddle, &mut Transform)>,
+) {
+    let (paddle, mut transform) = query.single_mut();
+    let mut direction = 0.0;
+    if keyboard_input.pressed(KeyCode::Left) {
+        direction -= 1.0;
+    }
+
+    if keyboard_input.pressed(KeyCode::Right) {
+        direction += 1.0;
+    }
+
+    let translation = &mut transform.translation;
+    // move the paddle horizontally
+    translation.x += direction * paddle.speed * TIME_STEP;
+    // bound the paddle within the walls
+    translation.x = translation.x.min(380.0).max(-380.0);
+}
+
+fn ball_movement_system(mut ball_query: Query<(&Ball, &mut Transform)>) {
+    let (ball, mut transform) = ball_query.single_mut();
+    transform.translation += ball.velocity * TIME_STEP;
+}
+
+fn scoreboard_system(scoreboard: Res<Scoreboard>, mut query: Query<&mut Text>) {
+    let mut text = query.single_mut();
+    text.sections[1].value = format!("{}", scoreboard.score);
+}
+
+fn ball_collision_system(
+    mut commands: Commands,
+    mut scoreboard: ResMut<Scoreboard>,
+    mut ball_query: Query<(&mut Ball, &Transform)>,
+    collider_query: Query<(Entity, &Collider, &Transform)>,
+) {
+    let (mut ball, ball_transform) = ball_query.single_mut();
+    let ball_size = ball_transform.scale.truncate();
+    let velocity = &mut ball.velocity;
+
+    // check collision with walls
+    for (collider_entity, collider, transform) in collider_query.iter() {
+        let collision = collide(
+            ball_transform.translation,
+            ball_size,
+            transform.translation,
+            transform.scale.truncate(),
+        );
+        if let Some(collision) = collision {
+            // scorable colliders should be despawned and increment the scoreboard on collision
+            if let Collider::Scorable = *collider {
+                scoreboard.score += 1;
+                commands.entity(collider_entity).despawn();
+            }
+
+            // reflect the ball when it collides
+            let mut reflect_x = false;
+            let mut reflect_y = false;
+
+            // only reflect if the ball's velocity is going in the opposite direction of the
+            // collision
+            match collision {
+                Collision::Left => reflect_x = velocity.x > 0.0,
+                Collision::Right => reflect_x = velocity.x < 0.0,
+                Collision::Top => reflect_y = velocity.y < 0.0,
+                Collision::Bottom => reflect_y = velocity.y > 0.0,
+                Collision::Inside => { /* do nothing */ }
+            }
+
+            // reflect velocity on the x-axis if we hit something on the x-axis
+            if reflect_x {
+                velocity.x = -velocity.x;
+            }
+
+            // reflect velocity on the y-axis if we hit something on the y-axis
+            if reflect_y {
+                velocity.y = -velocity.y;
+            }
+
+            // break if this collide is on a solid, otherwise continue check whether a solid is
+            // also in collision
+            if let Collider::Solid = *collider {
+                break;
+            }
+        }
+    }
+}
 use bevy::{
     core::FixedTimestep,
     prelude::*,
diff --git a/examples/shader/animate_shader.rs b/examples/shader/animate_shader.rs
index e59de3447e2dbf..c47014432b55e3 100644
--- a/examples/shader/animate_shader.rs
+++ b/examples/shader/animate_shader.rs
@@ -1,125 +1,261 @@
 use bevy::{
+    core_pipeline::Transparent3d,
+    ecs::system::{lifetimeless::SRes, SystemParamItem},
+    pbr::{
+        DrawMesh, MeshPipeline, MeshPipelineKey, MeshUniform, SetMeshBindGroup,
+        SetMeshViewBindGroup,
+    },
     prelude::*,
-    reflect::TypeUuid,
     render::{
-        mesh::shape,
-        pipeline::{PipelineDescriptor, RenderPipeline},
-        render_graph::{base, RenderGraph, RenderResourcesNode},
-        renderer::RenderResources,
-        shader::{ShaderStage, ShaderStages},
+        mesh::MeshVertexBufferLayout,
+        render_asset::RenderAssets,
+        render_phase::{
+            AddRenderCommand, DrawFunctions, EntityRenderCommand, RenderCommandResult, RenderPhase,
+            SetItemPipeline, TrackedRenderPass,
+        },
+        render_resource::*,
+        renderer::{RenderDevice, RenderQueue},
+        view::{ComputedVisibility, ExtractedView, Msaa, Visibility},
+        RenderApp, RenderStage,
     },
 };
 
-/// This example shows how to animate a shader, by passing the global `time.seconds_since_startup()`
-/// via a 'TimeComponent` to the shader.
-pub fn main() {
+fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
+        .add_plugin(CustomMaterialPlugin)
         .add_startup_system(setup)
-        .add_system(animate_shader)
         .run();
 }
 
-#[derive(Component, RenderResources, Default, TypeUuid)]
-#[uuid = "463e4b8a-d555-4fc2-ba9f-4c880063ba92"]
-struct TimeUniform {
-    value: f32,
+fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
+    // cube
+    commands.spawn().insert_bundle((
+        meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+        GlobalTransform::default(),
+        CustomMaterial,
+        Visibility::default(),
+        ComputedVisibility::default(),
+    ));
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..default()
+    });
 }
 
-const VERTEX_SHADER: &str = r#"
-#version 450
+#[derive(Component)]
+struct CustomMaterial;
 
-layout(location = 0) in vec3 Vertex_Position;
-layout(location = 1) in vec2 Vertex_Uv;
-layout(location = 0) out vec2 v_Uv;
+pub struct CustomMaterialPlugin;
 
-layout(set = 0, binding = 0) uniform CameraViewProj {
-    mat4 ViewProj;
-};
+impl Plugin for CustomMaterialPlugin {
+    fn build(&self, app: &mut App) {
+        let render_device = app.world.resource::<RenderDevice>();
+        let buffer = render_device.create_buffer(&BufferDescriptor {
+            label: Some("time uniform buffer"),
+            size: std::mem::size_of::<f32>() as u64,
+            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
 
-layout(set = 1, binding = 0) uniform Transform {
-    mat4 Model;
-};
+        app.sub_app_mut(RenderApp)
+            .add_render_command::<Transparent3d, DrawCustom>()
+            .insert_resource(TimeMeta {
+                buffer,
+                bind_group: None,
+            })
+            .init_resource::<CustomPipeline>()
+            .init_resource::<SpecializedMeshPipelines<CustomPipeline>>()
+            .add_system_to_stage(RenderStage::Extract, extract_time)
+            .add_system_to_stage(RenderStage::Extract, extract_custom_material)
+            .add_system_to_stage(RenderStage::Prepare, prepare_time)
+            .add_system_to_stage(RenderStage::Queue, queue_custom)
+            .add_system_to_stage(RenderStage::Queue, queue_time_bind_group);
+    }
+}
 
-void main() {
-    gl_Position = ViewProj * Model * vec4(Vertex_Position, 1.0);
-    v_Uv = Vertex_Uv;
+// extract the `CustomMaterial` component into the render world
+fn extract_custom_material(
+    mut commands: Commands,
+    mut previous_len: Local<usize>,
+    mut query: Query<Entity, With<CustomMaterial>>,
+) {
+    let mut values = Vec::with_capacity(*previous_len);
+    for entity in query.iter_mut() {
+        values.push((entity, (CustomMaterial,)));
+    }
+    *previous_len = values.len();
+    commands.insert_or_spawn_batch(values);
 }
-"#;
 
-const FRAGMENT_SHADER: &str = r#"
-#version 450
+// add each entity with a mesh and a `CustomMaterial` to every view's `Transparent3d` render phase using the `CustomPipeline`
+#[allow(clippy::too_many_arguments)]
+fn queue_custom(
+    transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
+    custom_pipeline: Res<CustomPipeline>,
+    msaa: Res<Msaa>,
+    mut pipelines: ResMut<SpecializedMeshPipelines<CustomPipeline>>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    render_meshes: Res<RenderAssets<Mesh>>,
+    material_meshes: Query<(Entity, &MeshUniform, &Handle<Mesh>), With<CustomMaterial>>,
+    mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
+) {
+    let draw_custom = transparent_3d_draw_functions
+        .read()
+        .get_id::<DrawCustom>()
+        .unwrap();
 
-layout(location = 0) in vec2 v_Uv;
-layout(location = 0) out vec4 o_Target;
+    let key = MeshPipelineKey::from_msaa_samples(msaa.samples)
+        | MeshPipelineKey::from_primitive_topology(PrimitiveTopology::TriangleList);
 
-layout(set = 2, binding = 0) uniform TimeUniform_value {
-    float time;
-};
+    for (view, mut transparent_phase) in views.iter_mut() {
+        let view_matrix = view.transform.compute_matrix();
+        let view_row_2 = view_matrix.row(2);
+        for (entity, mesh_uniform, mesh_handle) in material_meshes.iter() {
+            if let Some(mesh) = render_meshes.get(mesh_handle) {
+                let pipeline = pipelines
+                    .specialize(&mut pipeline_cache, &custom_pipeline, key, &mesh.layout)
+                    .unwrap();
+                transparent_phase.add(Transparent3d {
+                    entity,
+                    pipeline,
+                    draw_function: draw_custom,
+                    distance: view_row_2.dot(mesh_uniform.transform.col(3)),
+                });
+            }
+        }
+    }
+}
 
-void main() {
-    float speed = 0.7;
-    float translation = sin(time * speed);
-    float percentage = 0.6;
-    float threshold = v_Uv.x + translation * percentage;
+#[derive(Default)]
+struct ExtractedTime {
+    seconds_since_startup: f32,
+}
 
-    vec3 red = vec3(1., 0., 0.);
-    vec3 blue = vec3(0., 0., 1.);
-    vec3 mixed = mix(red, blue, threshold);
+// extract the passed time into a resource in the render world
+fn extract_time(mut commands: Commands, time: Res<Time>) {
+    commands.insert_resource(ExtractedTime {
+        seconds_since_startup: time.seconds_since_startup(),
+    });
+}
 
-    o_Target = vec4(mixed, 1.0);
+struct TimeMeta {
+    buffer: Buffer,
+    bind_group: Option<BindGroup>,
 }
-"#;
 
-fn setup(
-    mut commands: Commands,
-    mut pipelines: ResMut<Assets<PipelineDescriptor>>,
-    mut shaders: ResMut<Assets<Shader>>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut render_graph: ResMut<RenderGraph>,
+// write the extracted time into the corresponding uniform buffer
+fn prepare_time(
+    time: Res<ExtractedTime>,
+    time_meta: ResMut<TimeMeta>,
+    render_queue: Res<RenderQueue>,
 ) {
-    // Create a new shader pipeline.
-    let pipeline_handle = pipelines.add(PipelineDescriptor::default_config(ShaderStages {
-        vertex: shaders.add(Shader::from_glsl(ShaderStage::Vertex, VERTEX_SHADER)),
-        fragment: Some(shaders.add(Shader::from_glsl(ShaderStage::Fragment, FRAGMENT_SHADER))),
-    }));
-
-    // Add a `RenderResourcesNode` to our `RenderGraph`. This will bind `TimeComponent` to our
-    // shader.
-    render_graph.add_system_node(
-        "time_uniform",
-        RenderResourcesNode::<TimeUniform>::new(true),
+    render_queue.write_buffer(
+        &time_meta.buffer,
+        0,
+        bevy::core::cast_slice(&[time.seconds_since_startup]),
     );
+}
 
-    // Add a `RenderGraph` edge connecting our new "time_component" node to the main pass node. This
-    // ensures that "time_component" runs before the main pass.
-    render_graph
-        .add_node_edge("time_uniform", base::node::MAIN_PASS)
-        .unwrap();
-
-    // Spawn a quad and insert the `TimeComponent`.
-    commands
-        .spawn_bundle(MeshBundle {
-            mesh: meshes.add(Mesh::from(shape::Quad::new(Vec2::new(5.0, 5.0)))),
-            render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                pipeline_handle,
-            )]),
-            transform: Transform::from_xyz(0.0, 0.0, 0.0),
-            ..Default::default()
-        })
-        .insert(TimeUniform { value: 0.0 });
-
-    // Spawn a camera.
-    commands.spawn_bundle(PerspectiveCameraBundle {
-        transform: Transform::from_xyz(0.0, 0.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
-        ..Default::default()
+// create a bind group for the time uniform buffer
+fn queue_time_bind_group(
+    render_device: Res<RenderDevice>,
+    mut time_meta: ResMut<TimeMeta>,
+    pipeline: Res<CustomPipeline>,
+) {
+    let bind_group = render_device.create_bind_group(&BindGroupDescriptor {
+        label: None,
+        layout: &pipeline.time_bind_group_layout,
+        entries: &[BindGroupEntry {
+            binding: 0,
+            resource: time_meta.buffer.as_entire_binding(),
+        }],
     });
+    time_meta.bind_group = Some(bind_group);
 }
 
-/// In this system we query for the `TimeComponent` and global `Time` resource, and set
-/// `time.seconds_since_startup()` as the `value` of the `TimeComponent`. This value will be
-/// accessed by the fragment shader and used to animate the shader.
-fn animate_shader(time: Res<Time>, mut query: Query<&mut TimeUniform>) {
-    let mut time_uniform = query.single_mut();
-    time_uniform.value = time.seconds_since_startup();
+pub struct CustomPipeline {
+    shader: Handle<Shader>,
+    mesh_pipeline: MeshPipeline,
+    time_bind_group_layout: BindGroupLayout,
+}
+
+impl FromWorld for CustomPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let world = world.cell();
+        let asset_server = world.get_resource::<AssetServer>().unwrap();
+        let shader = asset_server.load("shaders/animate_shader.wgsl");
+
+        let render_device = world.get_resource_mut::<RenderDevice>().unwrap();
+        let time_bind_group_layout =
+            render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+                label: Some("time bind group"),
+                entries: &[BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(std::mem::size_of::<f32>() as u64),
+                    },
+                    count: None,
+                }],
+            });
+
+        let mesh_pipeline = world.get_resource::<MeshPipeline>().unwrap();
+
+        CustomPipeline {
+            shader,
+            mesh_pipeline: mesh_pipeline.clone(),
+            time_bind_group_layout,
+        }
+    }
+}
+
+impl SpecializedMeshPipeline for CustomPipeline {
+    type Key = MeshPipelineKey;
+
+    fn specialize(
+        &self,
+        key: Self::Key,
+        layout: &MeshVertexBufferLayout,
+    ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError> {
+        let mut descriptor = self.mesh_pipeline.specialize(key, layout)?;
+        descriptor.vertex.shader = self.shader.clone();
+        descriptor.fragment.as_mut().unwrap().shader = self.shader.clone();
+        descriptor.layout = Some(vec![
+            self.mesh_pipeline.view_layout.clone(),
+            self.mesh_pipeline.mesh_layout.clone(),
+            self.time_bind_group_layout.clone(),
+        ]);
+        Ok(descriptor)
+    }
+}
+
+type DrawCustom = (
+    SetItemPipeline,
+    SetMeshViewBindGroup<0>,
+    SetMeshBindGroup<1>,
+    SetTimeBindGroup<2>,
+    DrawMesh,
+);
+
+struct SetTimeBindGroup<const I: usize>;
+impl<const I: usize> EntityRenderCommand for SetTimeBindGroup<I> {
+    type Param = SRes<TimeMeta>;
+
+    fn render<'w>(
+        _view: Entity,
+        _item: Entity,
+        time_meta: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let time_bind_group = time_meta.into_inner().bind_group.as_ref().unwrap();
+        pass.set_bind_group(I, time_bind_group, &[]);
+
+        RenderCommandResult::Success
+    }
 }
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index 39701f4924e61b..ca0915925e79ca 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -4,17 +4,16 @@ use bevy::{
     prelude::*,
     window::PresentMode,
 };
-use rand::random;
+use rand::{thread_rng, Rng};
 
 const BIRDS_PER_SECOND: u32 = 10000;
-const _BASE_COLOR: Color = Color::rgb(5.0, 5.0, 5.0);
 const GRAVITY: f32 = -9.8 * 100.0;
 const MAX_VELOCITY: f32 = 750.;
 const BIRD_SCALE: f32 = 0.15;
 const HALF_BIRD_SIZE: f32 = 256. * BIRD_SCALE * 0.5;
 
 struct BevyCounter {
-    pub count: u128,
+    pub count: usize,
     pub color: Color,
 }
 
@@ -23,15 +22,18 @@ struct Bird {
     velocity: Vec3,
 }
 
+/// This example provides a 2D benchmark.
+///
+/// Usage: spawn more entities by clicking on the screen.
 fn main() {
     App::new()
         .insert_resource(WindowDescriptor {
             title: "BevyMark".to_string(),
             width: 800.,
             height: 600.,
-            present_mode: PresentMode::Mailbox,
+            present_mode: PresentMode::Immediate,
             resizable: true,
-            ..Default::default()
+            ..default()
         })
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
@@ -47,15 +49,15 @@ 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();
 }
 
 struct BirdScheduled {
-    wave: u128,
-    per_wave: u128,
+    wave: usize,
+    per_wave: usize,
 }
 
 fn scheduled_spawner(
@@ -73,77 +75,90 @@ fn scheduled_spawner(
             scheduled.per_wave,
             bird_texture.0.clone_weak(),
         );
-        counter.color = Color::rgb_linear(random(), random(), random());
+
+        let mut rng = thread_rng();
+        counter.color = Color::rgb_linear(rng.gen(), rng.gen(), rng.gen());
         scheduled.wave -= 1;
     }
 }
 
 struct BirdTexture(Handle<Image>);
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+#[derive(Component)]
+struct StatsText;
+
+fn setup(
+    mut commands: Commands,
+    mut fixed_time: ResMut<FixedTime>,
+    asset_server: Res<AssetServer>,
+) {
+    fixed_time.set_delta_f32(0.2);
+
     let texture = asset_server.load("branding/icon.png");
 
     commands.spawn_bundle(OrthographicCameraBundle::new_2d());
     commands.spawn_bundle(UiCameraBundle::default());
-    commands.spawn_bundle(TextBundle {
-        text: Text {
-            sections: vec![
-                TextSection {
-                    value: "Bird Count: ".to_string(),
-                    style: TextStyle {
-                        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-                        font_size: 40.0,
-                        color: Color::rgb(0.0, 1.0, 0.0),
+    commands
+        .spawn_bundle(TextBundle {
+            text: Text {
+                sections: vec![
+                    TextSection {
+                        value: "Bird Count: ".to_string(),
+                        style: TextStyle {
+                            font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                            font_size: 40.0,
+                            color: Color::rgb(0.0, 1.0, 0.0),
+                        },
                     },
-                },
-                TextSection {
-                    value: "".to_string(),
-                    style: TextStyle {
-                        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-                        font_size: 40.0,
-                        color: Color::rgb(0.0, 1.0, 1.0),
+                    TextSection {
+                        value: "".to_string(),
+                        style: TextStyle {
+                            font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                            font_size: 40.0,
+                            color: Color::rgb(0.0, 1.0, 1.0),
+                        },
                     },
-                },
-                TextSection {
-                    value: "\nAverage FPS: ".to_string(),
-                    style: TextStyle {
-                        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-                        font_size: 40.0,
-                        color: Color::rgb(0.0, 1.0, 0.0),
+                    TextSection {
+                        value: "\nAverage FPS: ".to_string(),
+                        style: TextStyle {
+                            font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                            font_size: 40.0,
+                            color: Color::rgb(0.0, 1.0, 0.0),
+                        },
                     },
-                },
-                TextSection {
-                    value: "".to_string(),
-                    style: TextStyle {
-                        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-                        font_size: 40.0,
-                        color: Color::rgb(0.0, 1.0, 1.0),
+                    TextSection {
+                        value: "".to_string(),
+                        style: TextStyle {
+                            font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                            font_size: 40.0,
+                            color: Color::rgb(0.0, 1.0, 1.0),
+                        },
                     },
+                ],
+                ..default()
+            },
+            style: Style {
+                position_type: PositionType::Absolute,
+                position: Rect {
+                    top: Val::Px(5.0),
+                    left: Val::Px(5.0),
+                    ..default()
                 },
-            ],
-            ..Default::default()
-        },
-        style: Style {
-            position_type: PositionType::Absolute,
-            position: Rect {
-                top: Val::Px(5.0),
-                left: Val::Px(5.0),
-                ..Default::default()
+                ..default()
             },
-            ..Default::default()
-        },
-        ..Default::default()
-    });
+            ..default()
+        })
+        .insert(StatsText);
 
     commands.insert_resource(BirdTexture(texture));
     commands.insert_resource(BirdScheduled {
         per_wave: std::env::args()
             .nth(1)
-            .and_then(|arg| arg.parse::<u128>().ok())
+            .and_then(|arg| arg.parse::<usize>().ok())
             .unwrap_or_default(),
         wave: std::env::args()
             .nth(2)
-            .and_then(|arg| arg.parse::<u128>().ok())
+            .and_then(|arg| arg.parse::<usize>().ok())
             .unwrap_or(1),
     });
 }
@@ -157,11 +172,12 @@ fn mouse_handler(
     mut counter: ResMut<BevyCounter>,
 ) {
     if mouse_button_input.just_released(MouseButton::Left) {
-        counter.color = Color::rgb_linear(random(), random(), random());
+        let mut rng = thread_rng();
+        counter.color = Color::rgb_linear(rng.gen(), rng.gen(), rng.gen());
     }
 
     if mouse_button_input.pressed(MouseButton::Left) {
-        let spawn_count = (BIRDS_PER_SECOND as f64 * time.delta_seconds_f64()) as u128;
+        let spawn_count = (BIRDS_PER_SECOND as f64 * time.delta_seconds_f64()) as usize;
         spawn_birds(
             &mut commands,
             &windows,
@@ -176,12 +192,14 @@ fn spawn_birds(
     commands: &mut Commands,
     windows: &Windows,
     counter: &mut BevyCounter,
-    spawn_count: u128,
+    spawn_count: usize,
     texture: Handle<Image>,
 ) {
     let window = windows.get_primary().unwrap();
     let bird_x = (window.width() as f32 / -2.) + HALF_BIRD_SIZE;
     let bird_y = (window.height() as f32 / 2.) - HALF_BIRD_SIZE;
+    let mut rng = thread_rng();
+
     for count in 0..spawn_count {
         let bird_z = (counter.count + count) as f32 * 0.00001;
         commands
@@ -190,17 +208,17 @@ fn spawn_birds(
                 transform: Transform {
                     translation: Vec3::new(bird_x, bird_y, bird_z),
                     scale: Vec3::splat(BIRD_SCALE),
-                    ..Default::default()
+                    ..default()
                 },
                 sprite: Sprite {
                     color: counter.color,
-                    ..Default::default()
+                    ..default()
                 },
-                ..Default::default()
+                ..default()
             })
             .insert(Bird {
                 velocity: Vec3::new(
-                    rand::random::<f32>() * MAX_VELOCITY - (MAX_VELOCITY * 0.5),
+                    rng.gen::<f32>() * MAX_VELOCITY - (MAX_VELOCITY * 0.5),
                     0.,
                     0.,
                 ),
@@ -245,14 +263,17 @@ fn collision_system(windows: Res<Windows>, mut bird_query: Query<(&mut Bird, &Tr
 fn counter_system(
     diagnostics: Res<Diagnostics>,
     counter: Res<BevyCounter>,
-    mut query: Query<&mut Text>,
+    mut query: Query<&mut Text, With<StatsText>>,
 ) {
+    let mut text = query.single_mut();
+
+    if counter.is_changed() {
+        text.sections[1].value = format!("{}", counter.count);
+    }
+
     if let Some(fps) = diagnostics.get(FrameTimeDiagnosticsPlugin::FPS) {
         if let Some(average) = fps.average() {
-            for mut text in query.iter_mut() {
-                text.sections[1].value = format!("{}", counter.count);
-                text.sections[3].value = format!("{:.2}", average);
-            }
+            text.sections[3].value = format!("{:.2}", average);
         }
     };
 }
diff --git a/examples/wasm/winit_wasm.rs b/examples/wasm/winit_wasm.rs
deleted file mode 100644
index 2ed51b859cc079..00000000000000
--- a/examples/wasm/winit_wasm.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use bevy::{
-    input::{
-        keyboard::KeyboardInput,
-        mouse::{MouseButtonInput, MouseMotion, MouseWheel},
-    },
-    prelude::*,
-};
-
-fn main() {
-    App::new()
-        .insert_resource(WindowDescriptor {
-            width: 300.,
-            height: 300.,
-            ..Default::default()
-        })
-        .add_plugins(DefaultPlugins)
-        // One time greet
-        .add_startup_system(hello_wasm_system)
-        // Track ticks (sanity check, whether game loop is running)
-        .add_system(counter)
-        // Track input events
-        .add_system(track_input_events)
-        .run();
-}
-
-fn hello_wasm_system() {
-    info!("hello wasm");
-}
-
-fn counter(mut state: Local<CounterState>, time: Res<Time>) {
-    if state.count % 60 == 0 {
-        info!(
-            "tick {} @ {:?} [Δ{}]",
-            state.count,
-            time.raw_elapsed_since_startup(),
-            time.raw_delta_seconds()
-        );
-    }
-    state.count += 1;
-}
-
-#[derive(Default)]
-struct CounterState {
-    count: u32,
-}
-
-fn track_input_events(
-    mut ev_keys: EventReader<KeyboardInput>,
-    mut ev_cursor: EventReader<CursorMoved>,
-    mut ev_motion: EventReader<MouseMotion>,
-    mut ev_mousebtn: EventReader<MouseButtonInput>,
-    mut ev_scroll: EventReader<MouseWheel>,
-) {
-    // Keyboard input
-    for ev in ev_keys.iter() {
-        if ev.state.is_pressed() {
-            info!("Just pressed key: {:?}", ev.key_code);
-        } else {
-            info!("Just released key: {:?}", ev.key_code);
-        }
-    }
-
-    // Absolute cursor position (in window coordinates)
-    for ev in ev_cursor.iter() {
-        info!("Cursor at: {}", ev.position);
-    }
-
-    // Relative mouse motion
-    for ev in ev_motion.iter() {
-        info!("Mouse moved {} pixels", ev.delta);
-    }
-
-    // Mouse buttons
-    for ev in ev_mousebtn.iter() {
-        if ev.state.is_pressed() {
-            info!("Just pressed mouse button: {:?}", ev.button);
-        } else {
-            info!("Just released mouse button: {:?}", ev.button);
-        }
-    }
-
-    // scrolling (mouse wheel, touchpad, etc.)
-    for ev in ev_scroll.iter() {
-        info!(
-            "Scrolled vertically by {} and horizontally by {}.",
-            ev.y, ev.x
-        );
-    }
-}

From 8f88394a2ca2108b542275a83f1861b4a3755e57 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 3 Mar 2022 20:23:29 -0800
Subject: [PATCH 19/27] fix breakout to match main

---
 examples/game/breakout.rs | 321 ++++++--------------------------------
 1 file changed, 44 insertions(+), 277 deletions(-)

diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 4ecb68c4045692..4f7c09beff2d38 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -45,6 +45,50 @@ struct Scoreboard {
     score: usize,
 }
 
+
+    
+const TIME_STEP: f32 = 1.0 / 60.0;
+
+/// An implementation of the classic game "Breakout"
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(Scoreboard { score: 0 })
+        .insert_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
+        .add_startup_system(setup)
+        .add_system_set(
+            SystemSet::new()
+                .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
+                .with_system(paddle_movement_system)
+                .with_system(ball_collision_system)
+                .with_system(ball_movement_system),
+        )
+        .add_system(scoreboard_system)
+        .add_system(bevy::input::system::exit_on_esc_system)
+        .run();
+}
+
+#[derive(Component)]
+struct Paddle {
+    speed: f32,
+}
+
+#[derive(Component)]
+struct Ball {
+    velocity: Vec3,
+}
+
+#[derive(Component)]
+enum Collider {
+    Solid,
+    Scorable,
+    Paddle,
+}
+
+struct Scoreboard {
+    score: usize,
+}
+
 fn setup(
     mut commands: Commands,
     mut fixed_time: ResMut<FixedTime>,
@@ -316,280 +360,3 @@ fn ball_collision_system(
         }
     }
 }
-use bevy::{
-    core::FixedTimestep,
-    prelude::*,
-    render::pass::ClearColor,
-    sprite::collide_aabb::{collide, Collision},
-};
-
-/// An implementation of the classic game "Breakout"
-fn main() {
-    App::new()
-        .add_plugins(DefaultPlugins)
-        .insert_resource(Scoreboard { score: 0 })
-        .insert_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
-        .add_startup_system(setup)
-        .add_system_set(
-            SystemSet::new()
-                .with_run_criteria(FixedTimestep::step)
-                .with_system(paddle_movement_system)
-                .with_system(ball_collision_system)
-                .with_system(ball_movement_system),
-        )
-        .add_system(scoreboard_system)
-        .add_system(bevy::input::system::exit_on_esc_system)
-        .run();
-}
-
-#[derive(Component)]
-struct Paddle {
-    speed: f32,
-}
-
-#[derive(Component)]
-struct Ball {
-    velocity: Vec3,
-}
-
-#[derive(Component)]
-enum Collider {
-    Solid,
-    Scorable,
-    Paddle,
-}
-
-struct Scoreboard {
-    score: usize,
-}
-
-fn setup(
-    mut commands: Commands,
-    mut time: ResMut<Time>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-    asset_server: Res<AssetServer>,
-) {
-    // Set timestep
-    time.set_steps_per_second(60.0);
-
-    // Add the game's entities to our world
-
-    // cameras
-    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
-    commands.spawn_bundle(UiCameraBundle::default());
-    // paddle
-    commands
-        .spawn_bundle(SpriteBundle {
-            material: materials.add(Color::rgb(0.5, 0.5, 1.0).into()),
-            transform: Transform::from_xyz(0.0, -215.0, 0.0),
-            sprite: Sprite::new(Vec2::new(120.0, 30.0)),
-            ..Default::default()
-        })
-        .insert(Paddle { speed: 500.0 })
-        .insert(Collider::Paddle);
-    // ball
-    commands
-        .spawn_bundle(SpriteBundle {
-            material: materials.add(Color::rgb(1.0, 0.5, 0.5).into()),
-            transform: Transform::from_xyz(0.0, -50.0, 1.0),
-            sprite: Sprite::new(Vec2::new(30.0, 30.0)),
-            ..Default::default()
-        })
-        .insert(Ball {
-            velocity: 400.0 * Vec3::new(0.5, -0.5, 0.0).normalize(),
-        });
-    // scoreboard
-    commands.spawn_bundle(TextBundle {
-        text: Text {
-            sections: vec![
-                TextSection {
-                    value: "Score: ".to_string(),
-                    style: TextStyle {
-                        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-                        font_size: 40.0,
-                        color: Color::rgb(0.5, 0.5, 1.0),
-                    },
-                },
-                TextSection {
-                    value: "".to_string(),
-                    style: TextStyle {
-                        font: asset_server.load("fonts/FiraMono-Medium.ttf"),
-                        font_size: 40.0,
-                        color: Color::rgb(1.0, 0.5, 0.5),
-                    },
-                },
-            ],
-            ..Default::default()
-        },
-        style: Style {
-            position_type: PositionType::Absolute,
-            position: Rect {
-                top: Val::Px(5.0),
-                left: Val::Px(5.0),
-                ..Default::default()
-            },
-            ..Default::default()
-        },
-        ..Default::default()
-    });
-
-    // Add walls
-    let wall_material = materials.add(Color::rgb(0.8, 0.8, 0.8).into());
-    let wall_thickness = 10.0;
-    let bounds = Vec2::new(900.0, 600.0);
-
-    // left
-    commands
-        .spawn_bundle(SpriteBundle {
-            material: wall_material.clone(),
-            transform: Transform::from_xyz(-bounds.x / 2.0, 0.0, 0.0),
-            sprite: Sprite::new(Vec2::new(wall_thickness, bounds.y + wall_thickness)),
-            ..Default::default()
-        })
-        .insert(Collider::Solid);
-    // right
-    commands
-        .spawn_bundle(SpriteBundle {
-            material: wall_material.clone(),
-            transform: Transform::from_xyz(bounds.x / 2.0, 0.0, 0.0),
-            sprite: Sprite::new(Vec2::new(wall_thickness, bounds.y + wall_thickness)),
-            ..Default::default()
-        })
-        .insert(Collider::Solid);
-    // bottom
-    commands
-        .spawn_bundle(SpriteBundle {
-            material: wall_material.clone(),
-            transform: Transform::from_xyz(0.0, -bounds.y / 2.0, 0.0),
-            sprite: Sprite::new(Vec2::new(bounds.x + wall_thickness, wall_thickness)),
-            ..Default::default()
-        })
-        .insert(Collider::Solid);
-    // top
-    commands
-        .spawn_bundle(SpriteBundle {
-            material: wall_material,
-            transform: Transform::from_xyz(0.0, bounds.y / 2.0, 0.0),
-            sprite: Sprite::new(Vec2::new(bounds.x + wall_thickness, wall_thickness)),
-            ..Default::default()
-        })
-        .insert(Collider::Solid);
-
-    // Add bricks
-    let brick_rows = 4;
-    let brick_columns = 5;
-    let brick_spacing = 20.0;
-    let brick_size = Vec2::new(150.0, 30.0);
-    let bricks_width = brick_columns as f32 * (brick_size.x + brick_spacing) - brick_spacing;
-    // center the bricks and move them up a bit
-    let bricks_offset = Vec3::new(-(bricks_width - brick_size.x) / 2.0, 100.0, 0.0);
-    let brick_material = materials.add(Color::rgb(0.5, 0.5, 1.0).into());
-    for row in 0..brick_rows {
-        let y_position = row as f32 * (brick_size.y + brick_spacing);
-        for column in 0..brick_columns {
-            let brick_position = Vec3::new(
-                column as f32 * (brick_size.x + brick_spacing),
-                y_position,
-                0.0,
-            ) + bricks_offset;
-            // brick
-            commands
-                .spawn_bundle(SpriteBundle {
-                    material: brick_material.clone(),
-                    sprite: Sprite::new(brick_size),
-                    transform: Transform::from_translation(brick_position),
-                    ..Default::default()
-                })
-                .insert(Collider::Scorable);
-        }
-    }
-}
-
-fn paddle_movement_system(
-    time: Res<Time>,
-    keyboard_input: Res<Input<KeyCode>>,
-    mut query: Query<(&Paddle, &mut Transform)>,
-) {
-    let (paddle, mut transform) = query.single_mut();
-    let mut direction = 0.0;
-    if keyboard_input.pressed(KeyCode::Left) {
-        direction -= 1.0;
-    }
-
-    if keyboard_input.pressed(KeyCode::Right) {
-        direction += 1.0;
-    }
-
-    let translation = &mut transform.translation;
-    // move the paddle horizontally
-    translation.x += direction * paddle.speed * time.fixed_delta_seconds();
-    // bound the paddle within the walls
-    translation.x = translation.x.min(380.0).max(-380.0);
-}
-
-fn ball_movement_system(time: Res<Time>, mut ball_query: Query<(&Ball, &mut Transform)>) {
-    let (ball, mut transform) = ball_query.single_mut();
-    transform.translation += ball.velocity * time.fixed_delta_seconds();
-}
-
-fn scoreboard_system(scoreboard: Res<Scoreboard>, mut query: Query<&mut Text>) {
-    let mut text = query.single_mut();
-    text.sections[1].value = format!("{}", scoreboard.score);
-}
-
-fn ball_collision_system(
-    mut commands: Commands,
-    mut scoreboard: ResMut<Scoreboard>,
-    mut ball_query: Query<(&mut Ball, &Transform, &Sprite)>,
-    collider_query: Query<(Entity, &Collider, &Transform, &Sprite)>,
-) {
-    let (mut ball, ball_transform, sprite) = ball_query.single_mut();
-    let ball_size = sprite.size;
-    let velocity = &mut ball.velocity;
-
-    // check collision with walls
-    for (collider_entity, collider, transform, sprite) in collider_query.iter() {
-        let collision = collide(
-            ball_transform.translation,
-            ball_size,
-            transform.translation,
-            sprite.size,
-        );
-        if let Some(collision) = collision {
-            // scorable colliders should be despawned and increment the scoreboard on collision
-            if let Collider::Scorable = *collider {
-                scoreboard.score += 1;
-                commands.entity(collider_entity).despawn();
-            }
-
-            // reflect the ball when it collides
-            let mut reflect_x = false;
-            let mut reflect_y = false;
-
-            // only reflect if the ball's velocity is going in the opposite direction of the
-            // collision
-            match collision {
-                Collision::Left => reflect_x = velocity.x > 0.0,
-                Collision::Right => reflect_x = velocity.x < 0.0,
-                Collision::Top => reflect_y = velocity.y < 0.0,
-                Collision::Bottom => reflect_y = velocity.y > 0.0,
-            }
-
-            // reflect velocity on the x-axis if we hit something on the x-axis
-            if reflect_x {
-                velocity.x = -velocity.x;
-            }
-
-            // reflect velocity on the y-axis if we hit something on the y-axis
-            if reflect_y {
-                velocity.y = -velocity.y;
-            }
-
-            // break if this collide is on a solid, otherwise continue check whether a solid is
-            // also in collision
-            if let Collider::Solid = *collider {
-                break;
-            }
-        }
-    }
-}

From a96dfd91dcc874a4d2a89c6aabf679cf7481536d Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 3 Mar 2022 20:25:05 -0800
Subject: [PATCH 20/27] fix breakout for real this time

---
 examples/game/breakout.rs | 45 +--------------------------------------
 1 file changed, 1 insertion(+), 44 deletions(-)

diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 4f7c09beff2d38..a7ee2fe6f67e4b 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -3,50 +3,7 @@ use bevy::{
     prelude::*,
     sprite::collide_aabb::{collide, Collision},
 };
-
-/// An implementation of the classic game "Breakout"
-const TIME_STEP: f32 = 1.0 / 60.0;
-fn main() {
-    App::new()
-        .add_plugins(DefaultPlugins)
-        .insert_resource(Scoreboard { score: 0 })
-        .insert_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
-        .add_startup_system(setup)
-        .add_system_set(
-            SystemSet::new()
-                .with_run_criteria(FixedTimestep::step)
-                .with_system(paddle_movement_system)
-                .with_system(ball_collision_system)
-                .with_system(ball_movement_system),
-        )
-        .add_system(scoreboard_system)
-        .add_system(bevy::input::system::exit_on_esc_system)
-        .run();
-}
-
-#[derive(Component)]
-struct Paddle {
-    speed: f32,
-}
-
-#[derive(Component)]
-struct Ball {
-    velocity: Vec3,
-}
-
-#[derive(Component)]
-enum Collider {
-    Solid,
-    Scorable,
-    Paddle,
-}
-
-struct Scoreboard {
-    score: usize,
-}
-
-
-    
+   
 const TIME_STEP: f32 = 1.0 / 60.0;
 
 /// An implementation of the classic game "Breakout"

From ea21b13a019179906ef944d4ed4b1d1a41f7efb7 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 3 Mar 2022 22:11:12 -0800
Subject: [PATCH 21/27] I can fix breakout, I swear

---
 crates/bevy_core/src/time/time.rs  | 14 ++++++++++++--
 examples/2d/rotation.rs            | 10 ++++++++--
 examples/ecs/iter_combinations.rs  |  2 +-
 examples/game/alien_cake_addict.rs |  2 +-
 examples/game/breakout.rs          |  4 ++--
 5 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 2b968eeb736db2..8de5a957e9727e 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -63,6 +63,9 @@ impl Time {
     pub(crate) fn update_with_instant(&mut self, instant: Instant) {
         if let Some(last_update) = self.last_update {
             self.raw_delta = instant - last_update;
+            self.raw_delta_seconds = self.raw_delta.as_secs_f32();
+            self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
+
             self.raw_elapsed_since_startup = instant - self.startup;
             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();
@@ -81,8 +84,9 @@ impl Time {
             self.seconds_since_startup_f64 = self.elapsed_since_startup.as_secs_f64();
         } else {
             self.first_update = Some(instant);
-
             let raw_delta = instant - self.startup;
+
+            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();
 
@@ -232,6 +236,7 @@ impl Time {
 
 use crate::{FixedTime, FixedTimestepState};
 use bevy_ecs::system::{Res, ResMut};
+
 pub(crate) fn time_system(
     mut time: ResMut<Time>,
     fixed_time: Option<Res<FixedTime>>,
@@ -261,11 +266,13 @@ pub(crate) fn time_system(
 mod tests {
     use super::Time;
     use bevy_utils::{Duration, Instant};
+
     #[test]
     fn update_test() {
-        let start_instant = Instant::now();
         // Create a `Time` for testing.
+        let start_instant = Instant::now();
         let mut time = Time::new(start_instant);
+
         // Ensure `time` was constructed correctly.
         assert_eq!(time.startup(), start_instant);
         assert_eq!(time.first_update(), None);
@@ -283,6 +290,7 @@ mod tests {
         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.
         // The first update to `time` normally happens before other systems have run,
         // so the first delta doesn't appear until the second update.
@@ -380,10 +388,12 @@ mod tests {
 
         // 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);
diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index 8ab5b7fd320502..09ec01442419b8 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -13,7 +13,7 @@ fn main() {
         .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),
@@ -51,7 +51,13 @@ struct RotateToPlayer {
 /// * Z axis goes from far to near (+Z points towards you, out of the screen)
 ///
 /// The origin is at the center of the screen.
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup(
+    mut commands: Commands,
+    mut fixed_time: ResMut<FixedTime>,
+    asset_server: Res<AssetServer>,
+) {
+    fixed_time.set_delta_f32(TIME_STEP);
+
     let ship_handle = asset_server.load("textures/simplespace/ship_C.png");
     let enemy_a_handle = asset_server.load("textures/simplespace/enemy_A.png");
     let enemy_b_handle = asset_server.load("textures/simplespace/enemy_B.png");
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index 82ce70f648835e..33790dbf69d9fc 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -168,7 +168,7 @@ fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)
 
 fn integrate(
     fixed_time: Res<FixedTime>,
-    mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>
+    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 query.iter_mut() {
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index 7b00c80c59819a..46d0ca2a43db94 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -408,4 +408,4 @@ fn display_score(mut commands: Commands, asset_server: Res<AssetServer>, game: R
                 ..default()
             });
         });
-}
\ No newline at end of file
+}
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index a7ee2fe6f67e4b..a96bb523e30c75 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -3,7 +3,7 @@ use bevy::{
     prelude::*,
     sprite::collide_aabb::{collide, Collision},
 };
-   
+
 const TIME_STEP: f32 = 1.0 / 60.0;
 
 /// An implementation of the classic game "Breakout"
@@ -15,7 +15,7 @@ fn main() {
         .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(paddle_movement_system)
                 .with_system(ball_collision_system)
                 .with_system(ball_movement_system),

From 8276f68b1b8ec521376d39a5709f0a6f18f2799b Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 3 Mar 2022 22:44:23 -0800
Subject: [PATCH 22/27] sync startup time between Time and FixedTime

a
---
 crates/bevy_core/src/lib.rs                 |  9 ++--
 crates/bevy_core/src/time/fixed_timestep.rs | 60 +++++++++++++++------
 crates/bevy_core/src/time/time.rs           | 12 ++---
 3 files changed, 55 insertions(+), 26 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 2b5d7943da60bd..eac21ed6890c3b 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -36,8 +36,7 @@ pub struct CorePlugin;
 /// A `SystemLabel` enum for ordering systems relative to core Bevy systems.
 #[derive(Debug, PartialEq, Eq, Clone, Hash, SystemLabel)]
 pub enum CoreSystem {
-    /// Updates the elapsed time. Any system that interacts with [Time] component should run after
-    /// this.
+    /// Advances time. Any system that interacts with the [`Time`] resource should run after this.
     Time,
 }
 
@@ -59,11 +58,11 @@ impl Plugin for CorePlugin {
             .register_type::<Name>()
             .register_type::<Range<f32>>()
             .register_type::<Timer>()
-            // time system is added as an "exclusive system" to ensure it runs before other systems
-            // in CoreStage::First
+            // Added as an "exclusive" system to ensure it runs before
+            // any other systems in CoreStage::First.
             .add_system_to_stage(
                 CoreStage::First,
-                time_system.exclusive_system().label(CoreSystem::Time),
+                update_time.exclusive_system().label(CoreSystem::Time),
             );
 
         register_rust_types(app);
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 1b9c6ea46c5f02..fe79376e5a2b99 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -1,7 +1,18 @@
-use bevy_ecs::{schedule::ShouldRun, system::ResMut};
+use bevy_ecs::{
+    schedule::ShouldRun,
+    system::ResMut,
+    world::{FromWorld, World},
+};
 use bevy_utils::{Duration, Instant};
 
-/// `FixedTime` tracks how much time has advanced since its previous update and since an app was started.
+use crate::Time;
+
+/// The default step size used for the fixed timestep.
+// 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_TIMESTEP: Duration = Duration::from_micros(15625); // 64Hz
+
+/// `FixedTime` tracks how much time has advanced since its previous update and since the app was started.
 ///
 /// It's just like [`Time`](super::time::Time) (and internally coupled to it), except it updates in fixed increments.
 #[derive(Debug, Clone)]
@@ -17,18 +28,18 @@ pub struct FixedTime {
     seconds_since_startup_f64: f64,
 }
 
-impl Default for FixedTime {
-    fn default() -> Self {
-        // 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.
-        let delta = Duration::from_micros(15625); // 64Hz
+impl FromWorld for FixedTime {
+    fn from_world(world: &mut World) -> Self {
+        let time = world
+            .get_resource::<Time>()
+            .expect("FixedTime depends on Time.");
         Self {
-            startup: Instant::now(),
+            startup: time.startup(),
             first_update: None,
             last_update: None,
-            delta,
-            delta_seconds: delta.as_secs_f32(),
-            delta_seconds_f64: delta.as_secs_f64(),
+            delta: DEFAULT_TIMESTEP,
+            delta_seconds: DEFAULT_TIMESTEP.as_secs_f32(),
+            delta_seconds_f64: DEFAULT_TIMESTEP.as_secs_f64(),
             elapsed_since_startup: Duration::ZERO,
             seconds_since_startup: 0.0,
             seconds_since_startup_f64: 0.0,
@@ -41,10 +52,14 @@ impl FixedTime {
     pub fn new(delta: Duration, startup: Instant) -> Self {
         Self {
             startup,
+            first_update: None,
+            last_update: None,
             delta,
             delta_seconds: delta.as_secs_f32(),
             delta_seconds_f64: delta.as_secs_f64(),
-            ..Default::default()
+            elapsed_since_startup: Duration::ZERO,
+            seconds_since_startup: 0.0,
+            seconds_since_startup_f64: 0.0,
         }
     }
 
@@ -102,6 +117,9 @@ impl FixedTime {
 
     /// Sets the timestep to `delta`, given as [`Duration`].
     ///
+    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will change system behavior.
+    ///
     /// # Panics
     ///
     /// Panics if `delta` is a zero-length duration.
@@ -115,6 +133,9 @@ impl FixedTime {
 
     /// Sets the timestep to `delta`, given as [`f32`].
     ///
+    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will change system behavior.
+    ///
     /// # Panics
     ///
     /// Panics if `delta` is less than or equal to zero, not finite, or overflows the `Duration`.
@@ -124,6 +145,9 @@ impl FixedTime {
 
     /// Sets the timestep to `delta`, given as [`f64`].
     ///
+    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will change system behavior.
+    ///
     /// # Panics
     ///
     /// Panics if `delta` is less than or equal to zero, not finite, or overflows the `Duration`.
@@ -145,23 +169,29 @@ impl FixedTime {
 
     /// Sets the timestep to the reciprocal of `rate`, given as [`f32`].
     ///
+    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will change system behavior.
+    ///
     /// # Panics
     ///
     /// Panics if `rate` is less than or equal to zero or not finite.
     #[inline]
     pub fn set_steps_per_second(&mut self, rate: f32) {
-        assert!(rate > 0.0 && rate.is_finite());
+        assert!(rate.is_sign_positive() && rate.is_finite());
         self.set_delta(Duration::from_secs_f32(1.0 / rate));
     }
 
     /// Sets the timestep to the reciprocal of `rate`, given as [`f64`].
     ///
+    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will change system behavior.
+    ///
     /// # Panics
     ///
     /// Panics if `rate` is less than or equal to zero or not finite.
     #[inline]
     pub fn set_steps_per_second_f64(&mut self, rate: f64) {
-        assert!(rate > 0.0 && rate.is_finite());
+        assert!(rate.is_sign_positive() && rate.is_finite());
         self.set_delta(Duration::from_secs_f64(1.0 / rate));
     }
 
@@ -184,7 +214,7 @@ impl FixedTime {
     }
 }
 
-/// Accumulates time and converts it into steps: one step per `timestep` accumulated.
+/// Accumulates time and converts it into steps: one step per `timestep` accumulated. Used to drive [`FixedTime`].
 #[derive(Debug, Clone)]
 pub struct FixedTimestepState {
     steps: u32,
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 8de5a957e9727e..4f780a00e27c54 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -1,6 +1,9 @@
+use bevy_ecs::system::{Res, ResMut};
 use bevy_utils::{Duration, Instant};
 
-/// `Time` tracks how much time has advanced (and also the raw CPU time elapsed) since its previous update and since an app was started.
+use crate::{FixedTime, FixedTimestepState};
+
+/// `Time` tracks how much time has advanced (and also the raw CPU time elapsed) since its previous update and since the app was started.
 #[derive(Debug, Clone)]
 pub struct Time {
     startup: Instant,
@@ -45,7 +48,7 @@ impl Default for Time {
 }
 
 impl Time {
-    /// Constructs a new `Time` instance with a specific startup time.
+    /// Constructs a new `Time` instance with a specific startup `Instant`.
     pub fn new(startup: Instant) -> Self {
         Self {
             startup,
@@ -234,10 +237,7 @@ impl Time {
     }
 }
 
-use crate::{FixedTime, FixedTimestepState};
-use bevy_ecs::system::{Res, ResMut};
-
-pub(crate) fn time_system(
+pub(crate) fn update_time(
     mut time: ResMut<Time>,
     fixed_time: Option<Res<FixedTime>>,
     accumulator: Option<ResMut<FixedTimestepState>>,

From 859fc1d0170925dded4937170bd21a557cb51e54 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sun, 6 Mar 2022 16:30:39 -0800
Subject: [PATCH 23/27] update with IceSentry feedback, assert messages, code
 quality

---
 crates/bevy_core/src/time/fixed_timestep.rs | 26 +++----
 crates/bevy_core/src/time/time.rs           | 78 ++++++++++-----------
 2 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index fe79376e5a2b99..27881413ec73ff 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -65,7 +65,8 @@ impl FixedTime {
 
     /// Updates internal time measurements.
     pub fn update(&mut self) {
-        self.update_with_instant(Instant::now());
+        let now = Instant::now();
+        self.update_with_instant(now);
     }
 
     /// Advances fixed time by the fixed delta and records the [`Instant`] it happened.
@@ -125,7 +126,7 @@ impl FixedTime {
     /// Panics if `delta` is a zero-length duration.
     #[inline]
     pub fn set_delta(&mut self, delta: Duration) {
-        assert_ne!(delta, Duration::ZERO);
+        assert!(!delta.is_zero(), "division by zero");
         self.delta = delta;
         self.delta_seconds = self.delta.as_secs_f32();
         self.delta_seconds_f64 = self.delta.as_secs_f64();
@@ -177,7 +178,8 @@ impl FixedTime {
     /// Panics if `rate` is less than or equal to zero or not finite.
     #[inline]
     pub fn set_steps_per_second(&mut self, rate: f32) {
-        assert!(rate.is_sign_positive() && rate.is_finite());
+        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));
     }
 
@@ -191,7 +193,8 @@ impl FixedTime {
     /// Panics if `rate` is less than or equal to zero or not finite.
     #[inline]
     pub fn set_steps_per_second_f64(&mut self, rate: f64) {
-        assert!(rate.is_sign_positive() && rate.is_finite());
+        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));
     }
 
@@ -256,7 +259,7 @@ impl FixedTimestepState {
     ///
     /// Panics if `timestep` is a zero-length duration.
     pub fn overstep_percentage(&self, timestep: Duration) -> f32 {
-        assert_ne!(timestep, Duration::ZERO);
+        assert!(!timestep.is_zero(), "division by zero");
         self.overstep.as_secs_f32() / timestep.as_secs_f32()
     }
 
@@ -268,7 +271,7 @@ impl FixedTimestepState {
     ///
     /// Panics if `timestep` is a zero-length duration.
     pub fn overstep_percentage_f64(&self, timestep: Duration) -> f64 {
-        assert_ne!(timestep, Duration::ZERO);
+        assert!(!timestep.is_zero(), "division by zero");
         self.overstep.as_secs_f64() / timestep.as_secs_f64()
     }
 
@@ -279,7 +282,7 @@ impl FixedTimestepState {
     ///
     /// Panics if `timestep` is a zero-length duration.
     pub fn add_time(&mut self, time: Duration, timestep: Duration) {
-        assert_ne!(timestep, Duration::ZERO);
+        assert!(!timestep.is_zero(), "division by zero");
         self.overstep += time;
         while self.overstep >= timestep {
             self.overstep -= timestep;
@@ -303,14 +306,13 @@ impl FixedTimestepState {
     }
 }
 
-/// A run criteria that enables a stage (or lone system) to run once per [`FixedTime::delta`] seconds advanced.
+/// A run criteria that queues a [`System`](bevy_ecs::system::System) or [`Stage`](bevy_ecs::schedule::Stage) to run once for every [`FixedTime::delta`] seconds advanced.
 ///
-/// That does **not** mean "once every `FixedTime::delta` seconds."
+/// That is **not** the same as "once every `FixedTime::delta` seconds."
 /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
 ///
-/// For example, a [`Stage`](bevy_ecs::schedule::Stage) set to run 60 steps per second will run once for every 16.7ms that [`Time`] advances,
-/// but unless [`Time::delta`] is always exactly 16.7ms, the actual measured time between steps will vary
-/// (the _average_ should be 16.7ms). Thus, for consistent behavior, users should avoid [`Time`] in the systems with this run criteria and use [`FixedTime`] instead.
+/// For example, a `Stage` set to run 100 steps per second will run whenever [`Time`] advances by 10ms,
+/// but unless the [`Time::delta`] is always exactly 10ms, the actual measured time between steps will vary. Thus, for consistent behavior, users should avoid `Time` in systems using this run criteria and use `FixedTime` instead.
 pub struct FixedTimestep;
 
 impl FixedTimestep {
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 4f780a00e27c54..0617c0e1fb72c2 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -66,46 +66,37 @@ impl Time {
     pub(crate) fn update_with_instant(&mut self, instant: Instant) {
         if let Some(last_update) = self.last_update {
             self.raw_delta = instant - last_update;
-            self.raw_delta_seconds = self.raw_delta.as_secs_f32();
-            self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
-
-            self.raw_elapsed_since_startup = instant - self.startup;
-            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();
-
-            // avoid any rounding errors when speed is 1:1
+            // Avoid rounding errors when the relative speed is 1.
             self.delta = if self.relative_speed != 1.0 {
                 self.raw_delta.mul_f64(self.relative_speed)
             } else {
                 self.raw_delta
             };
-            self.delta_seconds = self.delta.as_secs_f32();
-            self.delta_seconds_f64 = self.delta.as_secs_f64();
-
+            self.raw_elapsed_since_startup = instant - self.startup;
             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();
         } else {
             self.first_update = Some(instant);
             let raw_delta = instant - self.startup;
-
-            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();
-
-            // avoid any rounding errors when speed is 1:1
+            // 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
             };
-
+            self.raw_elapsed_since_startup += raw_delta;
             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.last_update = Some(instant);
+
+        // Cache floating-point values.
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
+        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_delta_seconds = self.raw_delta.as_secs_f32();
+        self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
+        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();
     }
 
     /// Returns the [`Instant`] the app was started.
@@ -146,22 +137,24 @@ impl Time {
     ///
     /// # Panics
     ///
-    /// Panics if `rate` negative or not finite.
+    /// Panics if `ratio` negative or not finite.
     #[inline]
-    pub fn set_relative_speed(&mut self, relative_speed: f32) {
-        assert!(relative_speed.is_sign_positive() && relative_speed.is_finite());
-        self.relative_speed = relative_speed as f64;
+    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 `rate` negative or not finite.
+    /// Panics if `ratio` negative or not finite.
     #[inline]
-    pub fn set_relative_speed_f64(&mut self, relative_speed: f64) {
-        assert!(relative_speed.is_sign_positive() && relative_speed.is_finite());
-        self.relative_speed = relative_speed;
+    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, as a [`Duration`].
@@ -237,26 +230,27 @@ impl Time {
     }
 }
 
+/// Advances `Time` and accumulates the amount advanced for `FixedTime`.
 pub(crate) fn update_time(
     mut time: ResMut<Time>,
     fixed_time: Option<Res<FixedTime>>,
     accumulator: Option<ResMut<FixedTimestepState>>,
 ) {
-    let first = time.last_update().is_none();
-    let now = Instant::now();
-    time.update_with_instant(now);
+    let is_first_update = time.first_update().is_none();
+    time.update();
+
     if let (Some(fixed_time), Some(mut accumulator)) = (fixed_time, accumulator) {
-        // `time.delta()` is kept zero on the first update, so we need to calculate it manually
-        let mut delta = if first {
-            now - time.startup()
+        // On first update, account for the exact startup delay so that `FixedTime` is synced.
+        let mut delta = if is_first_update {
+            time.first_update().unwrap() - time.startup()
         } else {
             time.raw_delta()
         };
-        // avoid any rounding errors when speed is 1:1
-        if time.relative_speed() != 1.0 {
+        // 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 elasped frame time
+        // Accumulate the time advanced.
         accumulator.add_time(delta, fixed_time.delta());
     }
 }
@@ -414,6 +408,10 @@ mod tests {
             time.seconds_since_startup(),
             (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,

From 202b4d95ed9334a47716577027aee8dee270f9d4 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sun, 6 Mar 2022 16:49:22 -0800
Subject: [PATCH 24/27] more refactoring

---
 crates/bevy_core/src/time/time.rs | 50 +++++++++++++++----------------
 1 file changed, 24 insertions(+), 26 deletions(-)

diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 0617c0e1fb72c2..8ee21014ad5611 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -64,39 +64,37 @@ impl Time {
 
     /// Advances time and records the [`Instant`] it happened.
     pub(crate) fn update_with_instant(&mut self, instant: Instant) {
-        if let Some(last_update) = self.last_update {
-            self.raw_delta = instant - last_update;
-            // Avoid rounding errors when the relative speed is 1.
-            self.delta = if self.relative_speed != 1.0 {
-                self.raw_delta.mul_f64(self.relative_speed)
-            } else {
-                self.raw_delta
-            };
-            self.raw_elapsed_since_startup = instant - self.startup;
-            self.elapsed_since_startup += self.delta;
+        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);
-            let raw_delta = 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
-            };
-            self.raw_elapsed_since_startup += raw_delta;
-            self.elapsed_since_startup += delta;
         }
-        self.last_update = Some(instant);
-
-        // Cache floating-point values.
-        self.delta_seconds = self.delta.as_secs_f32();
-        self.delta_seconds_f64 = self.delta.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_delta_seconds = self.raw_delta.as_secs_f32();
-        self.raw_delta_seconds_f64 = self.raw_delta.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);
     }
 
     /// Returns the [`Instant`] the app was started.

From b467063f80a8b52e1f4892de66040c7fc206525f Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sun, 6 Mar 2022 16:55:27 -0800
Subject: [PATCH 25/27] Update fixed_timestep.rs

---
 crates/bevy_core/src/time/fixed_timestep.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 27881413ec73ff..6ee02973150d08 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -306,13 +306,16 @@ impl FixedTimestepState {
     }
 }
 
-/// A run criteria that queues a [`System`](bevy_ecs::system::System) or [`Stage`](bevy_ecs::schedule::Stage) to run once for every [`FixedTime::delta`] seconds advanced.
+/// A run criteria that queues a [`System`](bevy_ecs::system::System) or [`Stage`](bevy_ecs::schedule::Stage)
+/// to run once for every [`FixedTime::delta`] seconds advanced.
 ///
 /// That is **not** the same as "once every `FixedTime::delta` seconds."
 /// The exact CPU time between steps depends on the frame rate and [`Time::relative_speed`].
 ///
 /// For example, a `Stage` set to run 100 steps per second will run whenever [`Time`] advances by 10ms,
-/// but unless the [`Time::delta`] is always exactly 10ms, the actual measured time between steps will vary. Thus, for consistent behavior, users should avoid `Time` in systems using this run criteria and use `FixedTime` instead.
+/// but unless the [`Time::delta`] is always exactly 10ms, the actual measured time between steps will vary.
+/// Thus, for consistent behavior, users should avoid `Time` in systems using this run criteria
+/// and use `FixedTime` instead.
 pub struct FixedTimestep;
 
 impl FixedTimestep {

From 399abde3cd965f587d25da5f6c3bbda2c681408b Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Mon, 7 Mar 2022 08:17:47 -0800
Subject: [PATCH 26/27] remove some #[inline]

---
 crates/bevy_core/src/time/fixed_timestep.rs | 4 ----
 crates/bevy_core/src/time/time.rs           | 2 --
 2 files changed, 6 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 6ee02973150d08..27d5d9e59abac7 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -124,7 +124,6 @@ impl FixedTime {
     /// # Panics
     ///
     /// Panics if `delta` is a zero-length duration.
-    #[inline]
     pub fn set_delta(&mut self, delta: Duration) {
         assert!(!delta.is_zero(), "division by zero");
         self.delta = delta;
@@ -176,7 +175,6 @@ impl FixedTime {
     /// # Panics
     ///
     /// Panics if `rate` is less than or equal to zero or not finite.
-    #[inline]
     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");
@@ -191,7 +189,6 @@ impl FixedTime {
     /// # Panics
     ///
     /// Panics if `rate` is less than or equal to zero or not finite.
-    #[inline]
     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");
@@ -299,7 +296,6 @@ impl FixedTimestepState {
     }
 
     /// Clears accumulated time and steps.
-    #[inline]
     pub fn reset(&mut self) {
         self.steps = 0;
         self.overstep = Duration::ZERO;
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 8ee21014ad5611..e2b761d76b5833 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -136,7 +136,6 @@ impl Time {
     /// # Panics
     ///
     /// Panics if `ratio` negative or not finite.
-    #[inline]
     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");
@@ -148,7 +147,6 @@ impl Time {
     /// # Panics
     ///
     /// Panics if `ratio` 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");

From 8394e9b720ea6a24acecaeab011f32bf891c8617 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Mon, 7 Mar 2022 08:49:10 -0800
Subject: [PATCH 27/27] docs

---
 crates/bevy_core/src/time/fixed_timestep.rs | 66 ++++++++++-----------
 crates/bevy_core/src/time/time.rs           | 36 +++++------
 2 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 27d5d9e59abac7..802894f0eb12a4 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -7,14 +7,14 @@ use bevy_utils::{Duration, Instant};
 
 use crate::Time;
 
-/// The default step size used for the fixed timestep.
+/// The default step size used by [`FixedTimestep`].
 // 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_TIMESTEP: Duration = Duration::from_micros(15625); // 64Hz
 
-/// `FixedTime` tracks how much time has advanced since its previous update and since the app was started.
+/// Tracks how much time has advanced since its previous update and since the app was started.
 ///
-/// It's just like [`Time`](super::time::Time) (and internally coupled to it), except it updates in fixed increments.
+/// It's just like [`Time`] (and internally coupled to it), except it advances in fixed increments.
 #[derive(Debug, Clone)]
 pub struct FixedTime {
     startup: Instant,
@@ -69,7 +69,7 @@ impl FixedTime {
         self.update_with_instant(now);
     }
 
-    /// Advances fixed time by the fixed delta and records the [`Instant`] it happened.
+    /// Advances time by [`FixedTime::delta`] and records the [`Instant`] it happened.
     pub(crate) fn update_with_instant(&mut self, instant: Instant) {
         if self.last_update.is_none() {
             self.first_update = Some(instant);
@@ -86,40 +86,40 @@ impl FixedTime {
         self.startup
     }
 
-    /// Returns the [`Instant`] when [`FixedTime::update`] was first called, if it exists.
+    /// Returns the [`Instant`] when [`update`](FixedTime::update) was first called, if it exists.
     #[inline]
     pub fn first_update(&self) -> Option<Instant> {
         self.first_update
     }
 
-    /// Returns the [`Instant`] when [`FixedTime::update`] was last called, if it exists.
+    /// Returns the [`Instant`] when [`update`](FixedTime::update) was last called, if it exists.
     #[inline]
     pub fn last_update(&self) -> Option<Instant> {
         self.last_update
     }
 
-    /// Returns how much fixed time advances in each update, as a [`Duration`].
+    /// Returns how much time advances with each [`update`](FixedTime::update), as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
         self.delta
     }
 
-    /// Returns how much fixed time advances in each update, as [`f32`] seconds.
+    /// Returns how much time advances with each [`update`](FixedTime::update), as [`f32`] seconds.
     #[inline]
     pub fn delta_seconds(&self) -> f32 {
         self.delta_seconds
     }
 
-    /// Returns how much fixed time advances in each update, as [`f64`] seconds.
+    /// Returns how much time advances with each [`update`](FixedTime::update), as [`f64`] seconds.
     #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
         self.delta_seconds_f64
     }
 
-    /// Sets the timestep to `delta`, given as [`Duration`].
+    /// Sets the timestep te `delta`, given as [`Duration`].
     ///
-    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
-    /// as changing the timestep itself will change system behavior.
+    /// Note: Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will likely change system behavior.
     ///
     /// # Panics
     ///
@@ -131,37 +131,37 @@ impl FixedTime {
         self.delta_seconds_f64 = self.delta.as_secs_f64();
     }
 
-    /// Sets the timestep to `delta`, given as [`f32`].
+    /// Sets the timestep te `delta`, given as [`f32`].
     ///
-    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
-    /// as changing the timestep itself will change system behavior.
+    /// Note: Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will likely change system behavior.
     ///
     /// # Panics
     ///
-    /// Panics if `delta` is less than or equal to zero, not finite, or overflows the `Duration`.
+    /// Panics if `delta` is less than or equal to zero, not finite, or overflows a `Duration`.
     pub fn set_delta_f32(&mut self, delta: f32) {
         self.set_delta(Duration::from_secs_f32(delta));
     }
 
-    /// Sets the timestep to `delta`, given as [`f64`].
+    /// Sets the timestep te `delta`, given as [`f64`].
     ///
-    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
-    /// as changing the timestep itself will change system behavior.
+    /// Note: Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will likely change system behavior.
     ///
     /// # Panics
     ///
-    /// Panics if `delta` is less than or equal to zero, not finite, or overflows the `Duration`.
+    /// Panics if `delta` is less than or equal to zero, not finite, or overflows a `Duration`.
     pub fn set_delta_f64(&mut self, delta: f64) {
         self.set_delta(Duration::from_secs_f64(delta));
     }
 
-    /// Returns the nominal fixed update rate (reciprocal of [`FixedTime::delta`]) as [`f32`].
+    /// Returns the nominal update rate (reciprocal of [`FixedTime::delta`]) as [`f32`].
     #[inline]
     pub fn steps_per_second(&self) -> f32 {
         1.0 / self.delta_seconds
     }
 
-    /// Returns the nominal fixed update rate (reciprocal of [`FixedTime::delta`]) as [`f64`].
+    /// Returns the nominal update rate (reciprocal of [`FixedTime::delta`]) as [`f64`].
     #[inline]
     pub fn steps_per_second_f64(&self) -> f64 {
         1.0 / self.delta_seconds_f64
@@ -169,8 +169,8 @@ impl FixedTime {
 
     /// Sets the timestep to the reciprocal of `rate`, given as [`f32`].
     ///
-    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
-    /// as changing the timestep itself will change system behavior.
+    /// Note: Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will likely change system behavior.
     ///
     /// # Panics
     ///
@@ -183,8 +183,8 @@ impl FixedTime {
 
     /// Sets the timestep to the reciprocal of `rate`, given as [`f64`].
     ///
-    /// Outside of startup, users should prefer using [`Time::set_relative_speed`]
-    /// as changing the timestep itself will change system behavior.
+    /// Note: Outside of startup, users should prefer using [`Time::set_relative_speed`]
+    /// as changing the timestep itself will likely change system behavior.
     ///
     /// # Panics
     ///
@@ -195,26 +195,26 @@ impl FixedTime {
         self.set_delta(Duration::from_secs_f64(1.0 / rate));
     }
 
-    /// Returns how much fixed time has advanced since startup, as [`Duration`].
+    /// Returns how much time has advanced since [`startup`](FixedTime::startup), as [`Duration`].
     #[inline]
     pub fn elapsed_since_startup(&self) -> Duration {
         self.elapsed_since_startup
     }
 
-    /// Returns how much fixed time has advanced since startup, as [`f32`] seconds.
+    /// Returns how much time has advanced since [`startup`](FixedTime::startup), as [`f32`] seconds.
     #[inline]
     pub fn seconds_since_startup(&self) -> f32 {
         self.seconds_since_startup
     }
 
-    /// Returns how much fixed time has advanced since startup, as [`f64`] seconds.
+    /// Returns how much time has advanced since [`startup`](FixedTime::startup), as [`f64`] seconds.
     #[inline]
     pub fn seconds_since_startup_f64(&self) -> f64 {
         self.seconds_since_startup_f64
     }
 }
 
-/// Accumulates time and converts it into steps: one step per `timestep` accumulated. Used to drive [`FixedTime`].
+/// Accumulates time and converts it into steps: one step per [`FixedTime::delta`] accumulated. Used to drive [`FixedTime`] and [`FixedTimestep`].
 #[derive(Debug, Clone)]
 pub struct FixedTimestepState {
     steps: u32,
@@ -250,7 +250,7 @@ impl FixedTimestepState {
 
     /// Returns the amount of time accumulated toward new steps, as an [`f32`] fraction of `timestep`.
     ///
-    /// Use this function when interpolating data between two timesteps.
+    /// Use this function when interpolating data between consecutive [`FixedTimestep`] iterations.
     ///
     /// # Panics
     ///
@@ -262,7 +262,7 @@ impl FixedTimestepState {
 
     /// Returns the amount of time accumulated toward new steps, as an [`f64`] fraction of `timestep`.
     ///
-    /// Use this function when interpolating data between two timesteps.
+    /// Use this function when interpolating data between consecutive [`FixedTimestep`] iterations.
     ///
     /// # Panics
     ///
@@ -273,7 +273,7 @@ impl FixedTimestepState {
     }
 
     /// Adds `time` to the internal `overstep`, then converts the `overstep` accumulated into
-    /// as many steps of size `timestep` as possible.
+    /// as many `timestep`-sized steps as possible.
     ///
     /// # Panics
     ///
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index e2b761d76b5833..b98774e93dd54a 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -3,7 +3,7 @@ use bevy_utils::{Duration, Instant};
 
 use crate::{FixedTime, FixedTimestepState};
 
-/// `Time` tracks how much time has advanced (and also the raw CPU time elapsed) since its previous update and since the app was 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(Debug, Clone)]
 pub struct Time {
     startup: Instant,
@@ -103,13 +103,13 @@ impl Time {
         self.startup
     }
 
-    /// Returns the [`Instant`] when [`Time::update`] was first called, if it exists.
+    /// Returns the [`Instant`] when [`update`](Time::update) was first called, if it exists.
     #[inline]
     pub fn first_update(&self) -> Option<Instant> {
         self.first_update
     }
 
-    /// Returns the [`Instant`] when [`Time::update`] was last called, if it exists.
+    /// Returns the [`Instant`] when [`update`](Time::update) was last called, if it exists.
     #[inline]
     pub fn last_update(&self) -> Option<Instant> {
         self.last_update
@@ -135,7 +135,7 @@ impl Time {
     ///
     /// # Panics
     ///
-    /// Panics if `ratio` negative or not finite.
+    /// 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");
@@ -146,87 +146,87 @@ impl Time {
     ///
     /// # Panics
     ///
-    /// Panics if `ratio` negative or not finite.
+    /// 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, as a [`Duration`].
+    /// Returns how much time has advanced since the last [`update`](Time::update), as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
         self.delta
     }
 
-    /// Returns how much time has advanced since the last update, as [`f32`] seconds.
+    /// Returns how much time has advanced since the last [`update`](Time::update), as [`f32`] seconds.
     #[inline]
     pub fn delta_seconds(&self) -> f32 {
         self.delta_seconds
     }
 
-    /// Returns how much time has advanced since the last update, as [`f64`] seconds.
+    /// Returns how much time has advanced since the last [`update`](Time::update), as [`f64`] seconds.
     #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
         self.delta_seconds_f64
     }
 
-    /// Returns the exact CPU time elapsed since the last update, as a [`Duration`].
+    /// Returns the exact CPU time elapsed since the last [`update`](Time::update), as a [`Duration`].
     #[inline]
     pub fn raw_delta(&self) -> Duration {
         self.raw_delta
     }
 
-    /// Returns the exact CPU time elapsed since the last update, as [`f32`] seconds.
+    /// Returns the exact CPU time elapsed since the last [`update`](Time::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, as [`f64`] seconds.
+    /// Returns the exact CPU time elapsed since the last [`update`](Time::update), as [`f64`] seconds.
     #[inline]
     pub fn raw_delta_seconds_f64(&self) -> f64 {
         self.raw_delta_seconds_f64
     }
 
-    /// Returns how much time has advanced since startup, as [`Duration`].
+    /// Returns how much time has advanced since [`startup`](Time::startup), as [`Duration`].
     #[inline]
     pub fn elapsed_since_startup(&self) -> Duration {
         self.elapsed_since_startup
     }
 
-    /// Returns how much time has advanced since startup, as [`f32`] seconds.
+    /// Returns how much time has advanced since [`startup`](Time::startup), as [`f32`] seconds.
     #[inline]
     pub fn seconds_since_startup(&self) -> f32 {
         self.seconds_since_startup
     }
 
-    /// Returns how much time has advanced since startup, as [`f64`] seconds.
+    /// Returns how much time has advanced since [`startup`](Time::startup), as [`f64`] seconds.
     #[inline]
     pub fn seconds_since_startup_f64(&self) -> f64 {
         self.seconds_since_startup_f64
     }
 
-    /// Returns the exact CPU time elapsed since startup, as [`Duration`].
+    /// Returns the exact CPU time elapsed since [`startup`](Time::startup), as [`Duration`].
     #[inline]
     pub fn raw_elapsed_since_startup(&self) -> Duration {
         self.raw_elapsed_since_startup
     }
 
-    /// Returns the exact CPU time elapsed since startup, as [`f32`] seconds.
+    /// Returns the exact CPU time elapsed since [`startup`](Time::startup), as [`f32`] seconds.
     #[inline]
     pub fn raw_seconds_since_startup(&self) -> f32 {
         self.raw_seconds_since_startup
     }
 
-    /// Returns the exact CPU time elapsed since startup, as [`f64`] seconds.
+    /// Returns the exact CPU time elapsed since [`startup`](Time::startup), as [`f64`] seconds.
     #[inline]
     pub fn raw_seconds_since_startup_f64(&self) -> f64 {
         self.raw_seconds_since_startup_f64
     }
 }
 
-/// Advances `Time` and accumulates the amount advanced for `FixedTime`.
+/// Advances [`Time`] and accumulates the amount advanced for [`FixedTime`].
 pub(crate) fn update_time(
     mut time: ResMut<Time>,
     fixed_time: Option<Res<FixedTime>>,