keep internal copy of step size to simplify API

crates/bevy_time/src/fixed_timestep.rs

@@ -12,7 +12,7 @@
 
 use bevy_app::FixedUpdate;
 use bevy_ecs::{system::Resource, world::World};
-use bevy_utils::{default, Duration, Instant};
+use bevy_utils::{default, Duration};
 
 use crate::{Time, TimeContext};
 
@@ -28,7 +28,7 @@ pub struct FixedTimestep {
 impl Default for FixedTimestep {
     fn default() -> Self {
         Self {
-            size: Duration::from_micros(15625),
+            size: Self::DEFAULT_STEP_SIZE,
             steps: 0,
             overstep: Duration::ZERO,
             max_steps_per_update: u32::MAX,
@@ -37,6 +37,9 @@ impl Default for FixedTimestep {
 }
 
 impl FixedTimestep {
+    /// The default step size.
+    pub const DEFAULT_STEP_SIZE: Duration = Duration::from_micros(15625);
+
     /// Constructs a new `FixedTimestep` from a [`Duration`].
     pub fn new(size: Duration) -> Self {
         assert!(!size.is_zero(), "timestep is zero");
@@ -139,11 +142,10 @@ pub fn run_fixed_update_schedule(world: &mut World) {
         }
 
         // run schedule however many times
-        let dt = timestep.size();
         for _ in 0..steps {
             let mut time = world.resource_mut::<Time>();
             assert!(matches!(time.context(), TimeContext::FixedUpdate));
-            time.tick(dt, Instant::now());
+            time.update();
             schedule.run(world);
         }
 

crates/bevy_time/src/lib.rs

@@ -139,6 +139,9 @@ fn time_system(
     // update virtual time clock
     time.update_with_instant(frame_start);
 
+    // apply any step size changes
+    time.fixed_timestep_size = fixed_timestep.size();
+
     // accumulate
     fixed_timestep.accumulate(time.delta());
 }

crates/bevy_time/src/time.rs

@@ -4,6 +4,7 @@ use bevy_utils::tracing::warn;
 use bevy_utils::{default, Duration, Instant};
 
 use crate::clock::Clock;
+use crate::fixed_timestep::FixedTimestep;
 
 /// A clock that tracks how much time has advanced since the last update and since startup.
 ///
@@ -15,6 +16,7 @@ pub struct Time {
     context: TimeContext,
     update: Clock,
     fixed_update: Clock,
+    pub(crate) fixed_timestep_size: Duration,
     paused: bool,
     next_paused: Option<bool>,
     relative_speed: f64, // using `f64` instead of `f32` to minimize drift from rounding errors
@@ -37,6 +39,7 @@ impl Default for Time {
             context: TimeContext::Update,
             update: default(),
             fixed_update: default(),
+            fixed_timestep_size: FixedTimestep::DEFAULT_STEP_SIZE,
             paused: false,
             next_paused: None,
             relative_speed: 1.0,
@@ -179,15 +182,11 @@ impl Time {
                 self.update.update(dt, instant);
             }
             TimeContext::FixedUpdate => {
-                warn!("In the `FixedUpdate` context, `Time` can only be advanced via `tick`.");
+                self.fixed_update.update(self.fixed_timestep_size, instant);
             }
         }
     }
 
-    pub(crate) fn tick(&mut self, dt: Duration, instant: Instant) {
-        self.current_clock_mut().update(dt, instant);
-    }
-
     /// Applies pending pause or relative speed changes.
     ///
     /// This method is provided for use in tests. Calling this method as part of your app will most