From b27370fb4334586cc8b870bc4177c3c5e3f974f6 Mon Sep 17 00:00:00 2001
From: Jondolf <jondolf.dev@gmail.com>
Date: Tue, 31 Oct 2023 22:51:02 +0200
Subject: [PATCH] Replace time resources with `Time<Physics>` and
 `Time<Substeps>`

---
 crates/benches_common_3d/src/lib.rs          |   6 +-
 crates/bevy_xpbd_2d/examples/move_marbles.rs |   2 +-
 src/constraints/mod.rs                       |   2 +-
 src/lib.rs                                   |   2 +-
 src/plugins/collision/broad_phase.rs         |   4 +-
 src/plugins/integrator.rs                    |  38 +++---
 src/plugins/mod.rs                           |   8 +-
 src/plugins/{setup.rs => setup/mod.rs}       | 130 ++++++++++---------
 src/plugins/setup/time.rs                    |  97 ++++++++++++++
 src/plugins/sleeping.rs                      |   4 +-
 src/plugins/solver.rs                        |  53 +++++---
 src/resources.rs                             |  55 +-------
 12 files changed, 237 insertions(+), 164 deletions(-)
 rename src/plugins/{setup.rs => setup/mod.rs} (77%)
 create mode 100644 src/plugins/setup/time.rs

diff --git a/crates/benches_common_3d/src/lib.rs b/crates/benches_common_3d/src/lib.rs
index 5875ece5..85397b2d 100644
--- a/crates/benches_common_3d/src/lib.rs
+++ b/crates/benches_common_3d/src/lib.rs
@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use bevy::{app::PluginsState, prelude::*};
 use bevy_xpbd_3d::prelude::*;
 use criterion::{measurement::Measurement, BatchSize, Bencher};
@@ -18,7 +20,9 @@ pub fn bench_app<M: Measurement>(
                 PhysicsPlugins::default(),
             ));
 
-            app.insert_resource(PhysicsTimestep::FixedOnce(1.0 / 60.0));
+            app.insert_resource(Time::new_with(Physics::FixedOnce(Duration::from_secs_f64(
+                1.0 / 64.0,
+            ))));
 
             setup(&mut app);
 
diff --git a/crates/bevy_xpbd_2d/examples/move_marbles.rs b/crates/bevy_xpbd_2d/examples/move_marbles.rs
index 4fadfb0c..0aad215f 100644
--- a/crates/bevy_xpbd_2d/examples/move_marbles.rs
+++ b/crates/bevy_xpbd_2d/examples/move_marbles.rs
@@ -8,7 +8,7 @@ fn main() {
     App::new()
         .add_plugins((DefaultPlugins, XpbdExamplePlugin))
         .insert_resource(ClearColor(Color::rgb(0.05, 0.05, 0.1)))
-        .insert_resource(SubstepCount(6))
+        .insert_resource(SubstepCount(5))
         .insert_resource(Gravity(Vector::NEG_Y * 1000.0))
         .add_systems(Startup, setup)
         .add_systems(Update, movement)
diff --git a/src/constraints/mod.rs b/src/constraints/mod.rs
index 3900ab7b..92073295 100644
--- a/src/constraints/mod.rs
+++ b/src/constraints/mod.rs
@@ -133,7 +133,7 @@
 //! ```
 //!
 //! where `w_i` is the inverse mass of particle `i`, `|▽C_i|` is the length of the gradient vector for particle `i`,
-//! `α` is the constraint's compliance (inverse of stiffness) and `h` is the [substep size](SubDeltaTime). Using `α = 0`
+//! `α` is the constraint's compliance (inverse of stiffness) and `h` is the substep size. Using `α = 0`
 //! corresponds to infinite stiffness.
 //!
 //! The minus sign is there because the gradients point in the direction in which `C` increases the most,
diff --git a/src/lib.rs b/src/lib.rs
index bffd1d2f..8b54c11b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -393,7 +393,7 @@
 //!         solve_velocities(particles and bodies)
 //! ```
 //!
-//! where `h` is the [substep size](SubDeltaTime), `q` is the [rotation](Rotation) as a quaternion,
+//! where `h` is the substep size, `q` is the [rotation](Rotation) as a quaternion,
 //! `ω` is the [angular velocity](AngularVelocity), `I` is the [angular inertia tensor](`Inertia`) and `τ` is the
 //! [external torque](ExternalTorque).
 //!
diff --git a/src/plugins/collision/broad_phase.rs b/src/plugins/collision/broad_phase.rs
index 15e33239..a7fec4f1 100644
--- a/src/plugins/collision/broad_phase.rs
+++ b/src/plugins/collision/broad_phase.rs
@@ -68,10 +68,10 @@ fn update_aabb(
         (&Position, Option<&LinearVelocity>, Option<&AngularVelocity>),
         With<Children>,
     >,
-    dt: Res<DeltaTime>,
+    dt: Res<Time>,
 ) {
     // Safety margin multiplier bigger than DELTA_TIME to account for sudden accelerations
-    let safety_margin_factor = 2.0 * dt.0;
+    let safety_margin_factor = 2.0 * dt.delta_seconds_adjusted();
 
     for (collider, mut aabb, pos, rot, collider_parent, lin_vel, ang_vel) in &mut colliders {
         let (lin_vel, ang_vel) = if let (Some(lin_vel), Some(ang_vel)) = (lin_vel, ang_vel) {
diff --git a/src/plugins/integrator.rs b/src/plugins/integrator.rs
index fc306af4..05873c3a 100644
--- a/src/plugins/integrator.rs
+++ b/src/plugins/integrator.rs
@@ -50,8 +50,10 @@ type PosIntegrationComponents = (
 fn integrate_pos(
     mut bodies: Query<PosIntegrationComponents, Without<Sleeping>>,
     gravity: Res<Gravity>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (
         rb,
         pos,
@@ -78,7 +80,7 @@ fn integrate_pos(
         if rb.is_dynamic() {
             // Apply damping
             if let Some(damping) = lin_damping {
-                lin_vel.0 *= 1.0 / (1.0 + sub_dt.0 * damping.0);
+                lin_vel.0 *= 1.0 / (1.0 + delta_secs * damping.0);
             }
 
             let effective_mass = locked_axes.apply_to_vec(Vector::splat(mass.0));
@@ -88,14 +90,14 @@ fn integrate_pos(
             let gravitation_force =
                 effective_mass * gravity.0 * gravity_scale.map_or(1.0, |scale| scale.0);
             let external_forces = gravitation_force + external_force.force();
-            let delta_lin_vel = sub_dt.0 * external_forces * effective_inv_mass;
+            let delta_lin_vel = delta_secs * external_forces * effective_inv_mass;
             // avoid triggering bevy's change detection unnecessarily
             if delta_lin_vel != Vector::ZERO {
                 lin_vel.0 += delta_lin_vel;
             }
         }
         if lin_vel.0 != Vector::ZERO {
-            translation.0 += locked_axes.apply_to_vec(sub_dt.0 * lin_vel.0);
+            translation.0 += locked_axes.apply_to_vec(delta_secs * lin_vel.0);
         }
     }
 }
@@ -116,10 +118,9 @@ type RotIntegrationComponents = (
 /// Explicitly integrates the rotations and angular velocities of bodies taking only external torque into account.
 /// This acts as a prediction for the next rotations of the bodies.
 #[cfg(feature = "2d")]
-fn integrate_rot(
-    mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>,
-    sub_dt: Res<SubDeltaTime>,
-) {
+fn integrate_rot(mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>, time: Res<Time>) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (
         rb,
         mut rot,
@@ -147,14 +148,14 @@ fn integrate_rot(
             if let Some(damping) = ang_damping {
                 // avoid triggering bevy's change detection unnecessarily
                 if ang_vel.0 != 0.0 && damping.0 != 0.0 {
-                    ang_vel.0 *= 1.0 / (1.0 + sub_dt.0 * damping.0);
+                    ang_vel.0 *= 1.0 / (1.0 + delta_secs * damping.0);
                 }
             }
 
             let effective_inv_inertia = locked_axes.apply_to_rotation(inv_inertia.0);
 
             // Apply external torque
-            let delta_ang_vel = sub_dt.0
+            let delta_ang_vel = delta_secs
                 * effective_inv_inertia
                 * (external_torque.torque() + external_force.torque());
             // avoid triggering bevy's change detection unnecessarily
@@ -163,7 +164,7 @@ fn integrate_rot(
             }
         }
         // avoid triggering bevy's change detection unnecessarily
-        let delta = locked_axes.apply_to_angular_velocity(sub_dt.0 * ang_vel.0);
+        let delta = locked_axes.apply_to_angular_velocity(delta_secs * ang_vel.0);
         if delta != 0.0 {
             *rot += Rotation::from_radians(delta);
         }
@@ -173,10 +174,9 @@ fn integrate_rot(
 /// Explicitly integrates the rotations and angular velocities of bodies taking only external torque into account.
 /// This acts as a prediction for the next rotations of the bodies.
 #[cfg(feature = "3d")]
-fn integrate_rot(
-    mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>,
-    sub_dt: Res<SubDeltaTime>,
-) {
+fn integrate_rot(mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>, time: Res<Time>) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (
         rb,
         mut rot,
@@ -204,7 +204,7 @@ fn integrate_rot(
             if let Some(damping) = ang_damping {
                 // avoid triggering bevy's change detection unnecessarily
                 if ang_vel.0 != Vector::ZERO && damping.0 != 0.0 {
-                    ang_vel.0 *= 1.0 / (1.0 + sub_dt.0 * damping.0);
+                    ang_vel.0 *= 1.0 / (1.0 + delta_secs * damping.0);
                 }
             }
 
@@ -212,7 +212,7 @@ fn integrate_rot(
             let effective_inv_inertia = locked_axes.apply_to_rotation(inv_inertia.rotated(&rot).0);
 
             // Apply external torque
-            let delta_ang_vel = sub_dt.0
+            let delta_ang_vel = delta_secs
                 * effective_inv_inertia
                 * ((external_torque.torque() + external_force.torque())
                     - ang_vel.0.cross(effective_inertia * ang_vel.0));
@@ -224,8 +224,8 @@ fn integrate_rot(
 
         let q = Quaternion::from_vec4(ang_vel.0.extend(0.0)) * rot.0;
         let effective_dq = locked_axes
-            .apply_to_angular_velocity(sub_dt.0 * 0.5 * q.xyz())
-            .extend(sub_dt.0 * 0.5 * q.w);
+            .apply_to_angular_velocity(delta_secs * 0.5 * q.xyz())
+            .extend(delta_secs * 0.5 * q.w);
         // avoid triggering bevy's change detection unnecessarily
         let delta = Quaternion::from_vec4(effective_dq);
         if delta != Quaternion::IDENTITY {
diff --git a/src/plugins/mod.rs b/src/plugins/mod.rs
index 62ba9aba..0b73706a 100644
--- a/src/plugins/mod.rs
+++ b/src/plugins/mod.rs
@@ -100,7 +100,7 @@ use bevy::prelude::*;
 /// only take affect the next frame.
 ///
 /// To advance the simulation by a certain amount of time instantly, you can set the value of
-/// the [`DeltaTime`] resource and manually run the [`PhysicsSchedule`] in an exclusive system:
+/// the [`Time<Physics>`] clock and manually run the [`PhysicsSchedule`] in an exclusive system:
 ///
 /// ```
 /// use bevy::prelude::*;
@@ -114,11 +114,11 @@ use bevy::prelude::*;
 )]
 ///
 /// fn run_physics(world: &mut World) {
-///     // Set the amount of time a step should take
-///     world.resource_mut::<DeltaTime>().0 = 1.0 / 120.0;
-///
 ///     // Advance the simulation by 10 steps at 120 Hz
 ///     for _ in 0..10 {
+///         world
+///             .resource_mut::<Time<Physics>>()
+///             .advance_by(Duration::from_secs_f64(1.0 / 120.0));
 ///         world.run_schedule(PhysicsSchedule);
 ///     }
 /// }
diff --git a/src/plugins/setup.rs b/src/plugins/setup/mod.rs
similarity index 77%
rename from src/plugins/setup.rs
rename to src/plugins/setup/mod.rs
index 9e2c76a3..7baed41e 100644
--- a/src/plugins/setup.rs
+++ b/src/plugins/setup/mod.rs
@@ -2,15 +2,19 @@
 //!
 //! See [`PhysicsSetupPlugin`].
 
+mod time;
+
+pub use time::*;
+
+use super::sync::PreviousGlobalTransform;
+use crate::prelude::*;
 use bevy::{
     ecs::schedule::{ExecutorKind, ScheduleBuildSettings},
+    prelude::*,
     transform::TransformSystem,
+    utils::intern::Interned,
 };
-
-use crate::prelude::*;
-
-use super::sync::PreviousGlobalTransform;
-use bevy::utils::intern::Interned;
+use std::time::Duration;
 
 /// Sets up the physics engine by initializing the necessary schedules, sets and resources.
 ///
@@ -57,19 +61,17 @@ impl Default for PhysicsSetupPlugin {
 impl Plugin for PhysicsSetupPlugin {
     fn build(&self, app: &mut App) {
         // Init resources and register component types
-        app.init_resource::<PhysicsTimestep>()
-            .init_resource::<PhysicsTimescale>()
-            .init_resource::<DeltaTime>()
-            .init_resource::<SubDeltaTime>()
+        app.init_resource::<PhysicsTimescale>()
+            .insert_resource(Time::new_with(Physics::default()))
+            .insert_resource(Time::new_with(Substeps))
             .init_resource::<SubstepCount>()
             .init_resource::<BroadCollisionPairs>()
             .init_resource::<SleepingThreshold>()
             .init_resource::<DeactivationTime>()
             .init_resource::<Gravity>()
-            .register_type::<PhysicsTimestep>()
             .register_type::<PhysicsTimescale>()
-            .register_type::<DeltaTime>()
-            .register_type::<SubDeltaTime>()
+            .register_type::<Time<Physics>>()
+            .register_type::<Time<Substeps>>()
             .register_type::<SubstepCount>()
             .register_type::<BroadCollisionPairs>()
             .register_type::<SleepingThreshold>()
@@ -302,27 +304,20 @@ fn run_physics_schedule(world: &mut World, mut is_first_run: Local<IsFirstRun>)
         .expect("no PhysicsLoop resource");
 
     #[cfg(feature = "f32")]
-    let mut delta_seconds = if physics_loop.fixed_update {
-        world.resource::<Time<Fixed>>().delta_seconds()
-    } else {
-        world.resource::<Time>().delta_seconds()
-    };
-
+    let mut delta_seconds = world.resource::<Time<Virtual>>().delta_seconds();
     #[cfg(feature = "f64")]
-    let mut delta_seconds = if physics_loop.fixed_update {
-        world.resource::<Time<Fixed>>().delta_seconds_f64()
-    } else {
-        world.resource::<Time>().delta_seconds_f64()
-    };
+    let mut delta_seconds = world.resource::<Time<Virtual>>().delta_seconds_f64();
+
+    let physics_clock = world.resource_mut::<Time<Physics>>();
 
-    let time_step = *world.resource::<PhysicsTimestep>();
+    let time_step = *physics_clock.context();
     let time_scale = world.resource::<PhysicsTimescale>().0.max(0.0);
 
-    // Update `DeltaTime` according to the `PhysicsTimestep` configuration
+    // Update `Time` according to the `PhysicsTimestep` configuration
     let (raw_dt, accumulate) = match time_step {
-        PhysicsTimestep::Fixed(fixed_delta_seconds) => (fixed_delta_seconds, true),
-        PhysicsTimestep::FixedOnce(fixed_delta_seconds) => (fixed_delta_seconds, false),
-        PhysicsTimestep::Variable { max_dt } => (delta_seconds.min(max_dt), true),
+        Physics::Fixed(fixed_delta_seconds) => (fixed_delta_seconds.as_secs_adjusted(), true),
+        Physics::FixedOnce(fixed_delta_seconds) => (fixed_delta_seconds.as_secs_adjusted(), false),
+        Physics::Variable { max_dt } => (delta_seconds.min(max_dt.as_secs_adjusted()), true),
     };
 
     // On the first run of the schedule, `delta_seconds` could be 0.0.
@@ -334,53 +329,66 @@ fn run_physics_schedule(world: &mut World, mut is_first_run: Local<IsFirstRun>)
         is_first_run.0 = false;
     }
 
-    let dt = raw_dt * time_scale;
-    world.resource_mut::<DeltaTime>().0 = dt;
+    let delta_seconds_scaled = raw_dt * time_scale;
+    let delta_time = Duration::from_secs_adjusted(delta_seconds_scaled);
 
-    match accumulate {
-        false if physics_loop.paused && physics_loop.queued_steps == 0 => {}
-        false => {
-            if physics_loop.queued_steps > 0 {
-                physics_loop.queued_steps -= 1;
-            }
-            debug!("running PhysicsSchedule");
-            world.run_schedule(PhysicsSchedule);
-        }
-        true => {
-            // Add time to the accumulator
-            if physics_loop.paused {
-                physics_loop.accumulator += dt * physics_loop.queued_steps as Scalar;
-                physics_loop.queued_steps = 0;
-            } else {
-                physics_loop.accumulator += delta_seconds * time_scale;
-            }
+    world.resource_mut::<Time<Physics>>().advance_by(delta_time);
 
-            // Step the simulation until the accumulator has been consumed.
-            // Note that a small remainder may be passed on to the next run of the physics schedule.
-            while physics_loop.accumulator >= dt && dt > 0.0 {
+    let _ = world.try_schedule_scope(PhysicsSchedule, |world, schedule| {
+        match accumulate {
+            false if physics_loop.paused && physics_loop.queued_steps == 0 => {}
+            false => {
+                if physics_loop.queued_steps > 0 {
+                    physics_loop.queued_steps -= 1;
+                }
                 debug!("running PhysicsSchedule");
-                world.run_schedule(PhysicsSchedule);
-                physics_loop.accumulator -= dt;
+                *world.resource_mut::<Time>() = world.resource::<Time<Physics>>().as_generic();
+                schedule.run(world);
+            }
+            true => {
+                // Add time to the accumulator
+                if physics_loop.paused {
+                    physics_loop.accumulator +=
+                        delta_seconds_scaled * physics_loop.queued_steps as Scalar;
+                    physics_loop.queued_steps = 0;
+                } else {
+                    physics_loop.accumulator += delta_seconds * time_scale;
+                }
+
+                // Step the simulation until the accumulator has been consumed.
+                // Note that a small remainder may be passed on to the next run of the physics schedule.
+                while physics_loop.accumulator >= delta_seconds_scaled && !delta_time.is_zero() {
+                    debug!("running PhysicsSchedule");
+                    *world.resource_mut::<Time>() = world.resource::<Time<Physics>>().as_generic();
+                    schedule.run(world);
+                    physics_loop.accumulator -= delta_seconds_scaled;
+                }
             }
         }
-    }
+    });
 
+    *world.resource_mut::<Time>() = world.resource::<Time<Virtual>>().as_generic();
     world.insert_resource(physics_loop);
 }
 
 /// Runs the [`SubstepSchedule`].
 fn run_substep_schedule(world: &mut World) {
+    let delta = world.resource::<Time<Physics>>().delta();
     let SubstepCount(substeps) = *world.resource::<SubstepCount>();
-    let dt = world.resource::<DeltaTime>().0;
+    let sub_delta = delta.div_f64(substeps as f64);
 
-    // Update `SubDeltaTime`
-    let mut sub_delta_time = world.resource_mut::<SubDeltaTime>();
-    sub_delta_time.0 = dt / substeps as Scalar;
+    let mut sub_delta_time = world.resource_mut::<Time<Substeps>>();
+    sub_delta_time.advance_by(sub_delta);
 
-    for i in 0..substeps {
-        debug!("running SubstepSchedule: {i}");
-        world.run_schedule(SubstepSchedule);
-    }
+    let _ = world.try_schedule_scope(SubstepSchedule, |world, schedule| {
+        for i in 0..substeps {
+            debug!("running SubstepSchedule: {i}");
+            *world.resource_mut::<Time>() = world.resource::<Time<Substeps>>().as_generic();
+            schedule.run(world);
+        }
+    });
+
+    *world.resource_mut::<Time>() = world.resource::<Time<Virtual>>().as_generic();
 }
 
 /// Runs the [`PostProcessCollisions`] schedule.
diff --git a/src/plugins/setup/time.rs b/src/plugins/setup/time.rs
new file mode 100644
index 00000000..af544b0c
--- /dev/null
+++ b/src/plugins/setup/time.rs
@@ -0,0 +1,97 @@
+//! Clocks used for tracking physics simulation time.
+
+use std::time::Duration;
+
+use bevy::prelude::*;
+
+use crate::prelude::*;
+
+/// The clock representing physics time, following `Time<Virtual>`.
+/// Can be configured to use a fixed or variable timestep.
+///
+/// The clock is automatically set as the generic `Time` resource for
+/// the [`SubstepSchedule`].
+#[derive(Reflect, Clone, Copy, Debug, PartialEq)]
+pub enum Physics {
+    /// **Fixed timestep**: the physics simulation will be advanced by a fixed value `dt` for every `dt` seconds passed since the previous physics frame. This allows consistent behavior across different machines and framerates.
+    Fixed(Duration),
+    /// **Fixed delta, once per frame**: the physics simulation will be advanced by a fixed value `dt` once every frame. This should only be used in cases where you can guarantee a fixed number of executions, like in FixedUpdate or on a server.
+    FixedOnce(Duration),
+    /// **Variable timestep**: the physics simulation will be advanced by `Time::delta_seconds().min(max_dt)` seconds at each Bevy tick.
+    Variable {
+        /// The maximum amount of time the physics simulation can be advanced at each Bevy tick. This makes sure that the simulation doesn't break when the delta time is large.
+        ///
+        /// A good default is `1.0 / 60.0` (60 Hz)
+        max_dt: Duration,
+    },
+}
+
+impl Default for Physics {
+    fn default() -> Self {
+        // Corresponds to 64 Hz.
+        Self::Fixed(Duration::from_micros(15625))
+    }
+}
+
+/// The clock representing physics substep time. It is updated based on
+/// [`Time<Physics>`](Physics) and the [`SubstepCount`] resource.
+///
+/// The clock is automatically set as the generic `Time` resource for
+/// the [`SubstepSchedule`].
+#[derive(Reflect, Clone, Copy, Debug, Default, PartialEq)]
+pub struct Substeps;
+
+pub(crate) trait TimePrecisionAdjusted {
+    /// Returns how much time has advanced since the last update
+    /// as [`Scalar`] seconds.
+    fn delta_seconds_adjusted(&self) -> Scalar;
+}
+
+pub(crate) trait DurationPrecisionAdjusted {
+    /// Returns the number of seconds contained by this Duration as [`Scalar`].
+    ///
+    /// The returned value does include the fractional (nanosecond) part of the duration.
+    fn as_secs_adjusted(&self) -> Scalar;
+
+    /// Creates a new Duration from the specified number of seconds represented as [`Scalar`].
+    fn from_secs_adjusted(secs: Scalar) -> Self;
+}
+
+impl TimePrecisionAdjusted for Time {
+    /// Returns how much time has advanced since the last [`update`](#method.update)
+    /// as [`Scalar`] seconds.
+    fn delta_seconds_adjusted(&self) -> Scalar {
+        #[cfg(feature = "f32")]
+        {
+            self.delta_seconds()
+        }
+        #[cfg(feature = "f64")]
+        {
+            self.delta_seconds_f64()
+        }
+    }
+}
+
+impl DurationPrecisionAdjusted for Duration {
+    fn as_secs_adjusted(&self) -> Scalar {
+        #[cfg(feature = "f32")]
+        {
+            self.as_secs_f32()
+        }
+        #[cfg(feature = "f64")]
+        {
+            self.as_secs_f64()
+        }
+    }
+
+    fn from_secs_adjusted(secs: Scalar) -> Self {
+        #[cfg(feature = "f32")]
+        {
+            Self::from_secs_f32(secs)
+        }
+        #[cfg(feature = "f64")]
+        {
+            Self::from_secs_f64(secs)
+        }
+    }
+}
diff --git a/src/plugins/sleeping.rs b/src/plugins/sleeping.rs
index 8fad8889..35d41338 100644
--- a/src/plugins/sleeping.rs
+++ b/src/plugins/sleeping.rs
@@ -51,7 +51,7 @@ fn mark_sleeping_bodies(
     mut bodies: Query<SleepingQueryComponents, (Without<Sleeping>, Without<SleepingDisabled>)>,
     deactivation_time: Res<DeactivationTime>,
     sleep_threshold: Res<SleepingThreshold>,
-    dt: Res<DeltaTime>,
+    dt: Res<Time>,
 ) {
     for (entity, rb, mut lin_vel, mut ang_vel, mut time_sleeping) in &mut bodies {
         // Only dynamic bodies can sleep.
@@ -73,7 +73,7 @@ fn mark_sleeping_bodies(
         // If linear and angular velocity are below the sleeping threshold,
         // add delta time to the time sleeping, i.e. the time that the body has remained still.
         if lin_vel_sq < lin_sleeping_threshold_sq && ang_vel_sq < ang_sleeping_threshold_sq {
-            time_sleeping.0 += dt.0;
+            time_sleeping.0 += dt.delta_seconds_adjusted();
         } else {
             time_sleeping.0 = 0.0;
         }
diff --git a/src/plugins/solver.rs b/src/plugins/solver.rs
index 6c281d45..dd422de3 100644
--- a/src/plugins/solver.rs
+++ b/src/plugins/solver.rs
@@ -98,8 +98,10 @@ fn penetration_constraints(
     colliders: Query<ColliderQuery>,
     mut penetration_constraints: ResMut<PenetrationConstraints>,
     mut collisions: ResMut<Collisions>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     penetration_constraints.0.clear();
 
     for ((collider_entity1, collider_entity2), contacts) in collisions
@@ -192,7 +194,7 @@ fn penetration_constraints(
                         restitution_coefficient,
                         ..PenetrationConstraint::new(&body1, &body2, contact)
                     };
-                    constraint.solve([&mut body1, &mut body2], sub_dt.0);
+                    constraint.solve([&mut body1, &mut body2], delta_secs);
                     penetration_constraints.0.push(constraint);
 
                     // Set collision as penetrating for this frame and substep.
@@ -235,8 +237,10 @@ pub fn solve_constraint<C: XpbdConstraint<ENTITY_COUNT> + Component, const ENTIT
     mut commands: Commands,
     mut bodies: Query<(RigidBodyQuery, Option<&Sleeping>)>,
     mut constraints: Query<&mut C, Without<RigidBody>>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     // Clear Lagrange multipliers
     constraints
         .iter_mut()
@@ -270,7 +274,7 @@ pub fn solve_constraint<C: XpbdConstraint<ENTITY_COUNT> + Component, const ENTIT
                 .collect::<Vec<&mut RigidBodyQueryItem>>()
                 .try_into()
             {
-                constraint.solve(bodies, sub_dt.0);
+                constraint.solve(bodies, delta_secs);
             }
         }
     }
@@ -290,8 +294,10 @@ fn update_lin_vel(
         ),
         Without<Sleeping>,
     >,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (rb, pos, prev_pos, translation, mut lin_vel, mut pre_solve_lin_vel) in &mut bodies {
         // Static bodies have no velocity
         if rb.is_static() && lin_vel.0 != Vector::ZERO {
@@ -302,9 +308,9 @@ fn update_lin_vel(
 
         if rb.is_dynamic() {
             // v = (x - x_prev) / h
-            let new_lin_vel = (pos.0 - prev_pos.0 + translation.0) / sub_dt.0;
+            let new_lin_vel = (pos.0 - prev_pos.0 + translation.0) / delta_secs;
             // avoid triggering bevy's change detection unnecessarily
-            if new_lin_vel != lin_vel.0 {
+            if new_lin_vel != lin_vel.0 && new_lin_vel.is_finite() {
                 lin_vel.0 = new_lin_vel;
             }
         }
@@ -324,8 +330,10 @@ fn update_ang_vel(
         ),
         Without<Sleeping>,
     >,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (rb, rot, prev_rot, mut ang_vel, mut pre_solve_ang_vel) in &mut bodies {
         // Static bodies have no velocity
         if rb.is_static() && ang_vel.0 != 0.0 {
@@ -335,9 +343,9 @@ fn update_ang_vel(
         pre_solve_ang_vel.0 = ang_vel.0;
 
         if rb.is_dynamic() {
-            let new_ang_vel = (rot.mul(prev_rot.inverse())).as_radians() / sub_dt.0;
+            let new_ang_vel = (rot.mul(prev_rot.inverse())).as_radians() / delta_secs;
             // avoid triggering bevy's change detection unnecessarily
-            if new_ang_vel != ang_vel.0 {
+            if new_ang_vel != ang_vel.0 && new_ang_vel.is_finite() {
                 ang_vel.0 = new_ang_vel;
             }
         }
@@ -357,8 +365,10 @@ fn update_ang_vel(
         ),
         Without<Sleeping>,
     >,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (rb, rot, prev_rot, mut ang_vel, mut pre_solve_ang_vel) in &mut bodies {
         // Static bodies have no velocity
         if rb.is_static() && ang_vel.0 != Vector::ZERO {
@@ -369,12 +379,12 @@ fn update_ang_vel(
 
         if rb.is_dynamic() {
             let delta_rot = rot.mul_quat(prev_rot.inverse().0);
-            let mut new_ang_vel = 2.0 * delta_rot.xyz() / sub_dt.0;
+            let mut new_ang_vel = 2.0 * delta_rot.xyz() / delta_secs;
             if delta_rot.w < 0.0 {
                 new_ang_vel = -new_ang_vel;
             }
             // avoid triggering bevy's change detection unnecessarily
-            if new_ang_vel != ang_vel.0 {
+            if new_ang_vel != ang_vel.0 && new_ang_vel.is_finite() {
                 ang_vel.0 = new_ang_vel;
             }
         }
@@ -387,8 +397,10 @@ fn solve_vel(
     mut bodies: Query<RigidBodyQuery, Without<Sleeping>>,
     penetration_constraints: Res<PenetrationConstraints>,
     gravity: Res<Gravity>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for constraint in penetration_constraints.0.iter() {
         if let Ok([mut body1, mut body2]) = bodies.get_many_mut(constraint.entities()) {
             if !body1.rb.is_dynamic() && !body2.rb.is_dynamic() {
@@ -442,7 +454,7 @@ fn solve_vel(
                 pre_solve_normal_speed,
                 constraint.restitution_coefficient,
                 gravity.0,
-                sub_dt.0,
+                delta_secs,
             );
             if restitution_speed.abs() > Scalar::EPSILON {
                 let w1 = constraint.compute_generalized_inverse_mass(&body1, r1, normal);
@@ -460,7 +472,7 @@ fn solve_vel(
                     w1 + w2,
                     constraint.dynamic_friction_coefficient,
                     constraint.normal_lagrange,
-                    sub_dt.0,
+                    delta_secs,
                 );
                 p += friction_impulse * tangent_dir;
             }
@@ -505,15 +517,17 @@ pub fn joint_damping<T: Joint>(
         Without<Sleeping>,
     >,
     joints: Query<&T, Without<RigidBody>>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for joint in &joints {
         if let Ok(
             [(rb1, mut lin_vel1, mut ang_vel1, inv_mass1, dominance1), (rb2, mut lin_vel2, mut ang_vel2, inv_mass2, dominance2)],
         ) = bodies.get_many_mut(joint.entities())
         {
             let delta_omega =
-                (ang_vel2.0 - ang_vel1.0) * (joint.damping_angular() * sub_dt.0).min(1.0);
+                (ang_vel2.0 - ang_vel1.0) * (joint.damping_angular() * delta_secs).min(1.0);
 
             if rb1.is_dynamic() {
                 ang_vel1.0 += delta_omega;
@@ -522,7 +536,8 @@ pub fn joint_damping<T: Joint>(
                 ang_vel2.0 -= delta_omega;
             }
 
-            let delta_v = (lin_vel2.0 - lin_vel1.0) * (joint.damping_linear() * sub_dt.0).min(1.0);
+            let delta_v =
+                (lin_vel2.0 - lin_vel1.0) * (joint.damping_linear() * delta_secs).min(1.0);
 
             let w1 = if rb1.is_dynamic() { inv_mass1.0 } else { 0.0 };
             let w2 = if rb2.is_dynamic() { inv_mass2.0 } else { 0.0 };
diff --git a/src/resources.rs b/src/resources.rs
index 80efa1aa..0a8b75a5 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -4,53 +4,12 @@ use bevy::prelude::Resource;
 
 use crate::prelude::*;
 
-/// Configures how many times per second the physics simulation is run.
-///
-/// ## Example
-///
-/// You can change the timestep by inserting the [`PhysicsTimestep`] resource:
-///
-/// ```no_run
-/// use bevy::prelude::*;
-#[cfg_attr(feature = "2d", doc = "use bevy_xpbd_2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use bevy_xpbd_3d::prelude::*;")]
-///
-/// fn main() {
-///     App::new()
-///         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
-///         // Use a 120 Hz fixed timestep instead of the default 60 Hz
-///         .insert_resource(PhysicsTimestep::Fixed(1.0 / 120.0))
-///         .run();
-/// }
-/// ```
-#[derive(Reflect, Resource, Clone, Copy, Debug, PartialEq)]
-#[reflect(Resource)]
-pub enum PhysicsTimestep {
-    /// **Fixed timestep**: the physics simulation will be advanced by a fixed value `dt` for every `dt` seconds passed since the previous physics frame. This allows consistent behavior across different machines and framerates.
-    Fixed(Scalar),
-    /// **Fixed delta, once per frame**: the physics simulation will be advanced by a fixed value `dt` once every frame. This should only be used in cases where you can guarantee a fixed number of executions, like in FixedUpdate or on a server.
-    FixedOnce(Scalar),
-    /// **Variable timestep**: the physics simulation will be advanced by `Time::delta_seconds().min(max_dt)` seconds at each Bevy tick.
-    Variable {
-        /// The maximum amount of time the physics simulation can be advanced at each Bevy tick. This makes sure that the simulation doesn't break when the delta time is large.
-        ///
-        /// A good default is `1.0 / 60.0` (60 Hz)
-        max_dt: Scalar,
-    },
-}
-
-impl Default for PhysicsTimestep {
-    fn default() -> Self {
-        Self::Fixed(1.0 / 60.0)
-    }
-}
-
 /// Configures the ratio of physics seconds per real second.
 ///
 /// The default time scale is 1.0, meaning the simulation runs in real time.
 /// Reduce this for slow motion, increase for fast forward.
 ///
-/// This changes the [`DeltaTime`] that the simulation is advanced by for each
+/// This changes the [`Time`] that the simulation is advanced by for each
 /// iteration. The frequency of physics updates, set using [`PhysicsTimestep`],
 /// remains unchanged.
 ///
@@ -86,19 +45,9 @@ impl Default for PhysicsTimescale {
     }
 }
 
-/// How much time the previous physics frame took. The timestep can be configured with the [`PhysicsTimestep`] resource.
-#[derive(Reflect, Resource, Default)]
-#[reflect(Resource)]
-pub struct DeltaTime(pub Scalar);
-
-/// How much time the previous physics substep took. This depends on the [`DeltaTime`] and [`SubstepCount`] resources.
-#[derive(Reflect, Resource, Default)]
-#[reflect(Resource)]
-pub struct SubDeltaTime(pub Scalar);
-
 /// The number of substeps used in the simulation.
 ///
-/// A higher number of substeps reduces the value of [`SubDeltaTime`],
+/// A higher number of substeps reduces the value of [`Time`],
 /// which results in a more accurate simulation, but also reduces performance. The default
 /// substep count is currently 12.
 ///