From ffc00068b5ce90e75b55985e9b238813f7652d87 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 17 Feb 2024 14:06:08 +0200
Subject: [PATCH] Add `ColliderBackendPlugin` and support generic colliders
 (#311)

# Objective

An improved version of #302.

Currently, collider logic is split across several plugins. The `PreparePlugin` initializes them and manages mass properties and collider parents, the `SyncPlugin` handles collider scale and transform propagation, the `BroadPhasePlugin` updates their AABBs and collects potential collision pairs, and the `NarrowPhasePlugin` uses them for actually computing contacts.

Using `Collider` in so many places isn't ideal since it couples collision logic with other plugins, and it also makes it very challenging to implement custom collision backends nicely. It would be useful to handle collider-specific background work in a single plugin and to support custom colliders through generics.

## Solution

- Add a `ColliderBackendPlugin`. It handles collider initialization, transform propagation, scaling, parents, mass property updates, AABB updates, and more.
- Add the `AnyCollider` and `ScalableCollider` traits. Implementing these for a component makes it possible to use a completely custom collider component by passing the type to `ColliderBackendPlugin` and `NarrowPhasePlugin` through generics. There is a new `custom_collider` example that demonstrates this.

To avoid leaking too many implementation details related to system ordering, I also added more system sets like the `BroadPhaseSet`, `NarrowPhaseSet` and `SyncSet` enums.

Creating a custom collision backend is now straightforward. After implementing `AnyCollider` and `ScalableCollider` for a component, simply add the `CollisionBackendPlugin` and `NarrowPhasePlugin` with that type:

```rust
.add_plugins((
    DefaultPlugins,
    PhysicsPlugins::default(),
    ColliderBackendPlugin::<CircleCollider>::default(),
    NarrowPhasePlugin::<CircleCollider>::default(),
))
```

---

## Changelog

### Added

- `CollisionBackendPlugin`
- `AnyCollider` trait
- `ScalableCollider` trait
- `scale_by` method for colliders
- `Collider::swept_aabb`
- `ColliderAabb::new`
- `ColliderAabb::merged`
- `BroadPhaseSet` system sets
- `NarrowPhaseSet` system sets
- `SyncSet` system sets
- `custom_collider` example

### Changed

- Moved `collider` module from `components` to `collision` module
- `NarrowPhasePlugin` takes a generic type implementing `AnyCollider`
- Moved collider systems from `PreparePlugin`, `SyncPlugin` and `SleepingPlugin` to `ColliderBackendPlugin`
- Collider logic from `upate_mass_properties` is in a new `update_collider_mass_properties` system

## Migration Guide

- Replace `NarrowPhasePlugin` with `NarrowPhasePlugin::<Collider>` if you add it manually
- Replace `Collider::compute_aabb` with `Collider::aabb`
---
 crates/bevy_xpbd_2d/Cargo.toml                |   4 +
 .../bevy_xpbd_2d/examples/custom_collider.rs  | 228 +++++
 src/components/mass_properties.rs             |  74 +-
 src/components/mod.rs                         |   4 +-
 src/components/rotation.rs                    |   2 +-
 src/components/world_queries.rs               |   2 +-
 src/lib.rs                                    |   2 +-
 src/plugins/collision/broad_phase.rs          | 149 +--
 .../collision}/collider.rs                    | 174 +++-
 src/plugins/collision/collider_backend.rs     | 884 ++++++++++++++++++
 src/plugins/collision/mod.rs                  |   4 +
 src/plugins/collision/narrow_phase.rs         | 132 ++-
 src/plugins/mod.rs                            |  11 +-
 src/plugins/prepare.rs                        | 479 ++--------
 src/plugins/sleeping.rs                       |  37 +-
 src/plugins/spatial_query/mod.rs              |   2 +-
 src/plugins/sync.rs                           | 346 ++-----
 17 files changed, 1550 insertions(+), 984 deletions(-)
 create mode 100644 crates/bevy_xpbd_2d/examples/custom_collider.rs
 rename src/{components => plugins/collision}/collider.rs (91%)
 create mode 100644 src/plugins/collision/collider_backend.rs

diff --git a/crates/bevy_xpbd_2d/Cargo.toml b/crates/bevy_xpbd_2d/Cargo.toml
index 823523d5..6336d02f 100644
--- a/crates/bevy_xpbd_2d/Cargo.toml
+++ b/crates/bevy_xpbd_2d/Cargo.toml
@@ -70,6 +70,10 @@ required-features = ["2d"]
 name = "collision_layers"
 required-features = ["2d"]
 
+[[example]]
+name = "custom_collider"
+required-features = ["2d"]
+
 [[example]]
 name = "fixed_joint_2d"
 required-features = ["2d"]
diff --git a/crates/bevy_xpbd_2d/examples/custom_collider.rs b/crates/bevy_xpbd_2d/examples/custom_collider.rs
new file mode 100644
index 00000000..0f5f5f52
--- /dev/null
+++ b/crates/bevy_xpbd_2d/examples/custom_collider.rs
@@ -0,0 +1,228 @@
+//! An example demonstrating how to make a custom collider and use it for collision detection.
+
+use bevy::{prelude::*, sprite::MaterialMesh2dBundle};
+use bevy_xpbd_2d::{math::*, prelude::*, PhysicsSchedule, PhysicsStepSet};
+use examples_common_2d::XpbdExamplePlugin;
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins,
+            XpbdExamplePlugin,
+            // Add collider backend for our custom collider.
+            // This handles things like initializing and updating required components
+            // and managing collider hierarchies.
+            ColliderBackendPlugin::<CircleCollider>::default(),
+            // Enable collision detection for our custom collider.
+            NarrowPhasePlugin::<CircleCollider>::default(),
+        ))
+        .insert_resource(ClearColor(Color::rgb(0.01, 0.01, 0.025)))
+        .insert_resource(Gravity::ZERO)
+        .add_systems(Startup, setup)
+        .add_systems(
+            PhysicsSchedule,
+            (center_gravity, rotate).before(PhysicsStepSet::BroadPhase),
+        )
+        .run();
+}
+
+/// A basic collider with a circle shape. Only supports uniform scaling.
+#[derive(Component)]
+struct CircleCollider {
+    /// The radius of the circle collider. This may be scaled by the `Transform` scale.
+    radius: Scalar,
+    /// The radius of the circle collider without `Transform` scale applied.
+    unscaled_radius: Scalar,
+    /// The scaling factor, determined by `Transform` scale.
+    scale: Scalar,
+}
+
+impl CircleCollider {
+    fn new(radius: Scalar) -> Self {
+        Self {
+            radius,
+            unscaled_radius: radius,
+            scale: 1.0,
+        }
+    }
+}
+
+impl AnyCollider for CircleCollider {
+    fn aabb(&self, position: Vector, _rotation: impl Into<Rotation>) -> ColliderAabb {
+        ColliderAabb::new(position, Vector::splat(self.radius))
+    }
+
+    fn mass_properties(&self, density: Scalar) -> ColliderMassProperties {
+        // In 2D, the Z length is assumed to be 1.0, so volume = area
+        let volume = bevy_xpbd_2d::math::PI * self.radius.powi(2);
+        let mass = density * volume;
+        let inertia = self.radius.powi(2) / 2.0;
+
+        ColliderMassProperties {
+            mass: Mass(mass),
+            inverse_mass: InverseMass(mass.recip()),
+            inertia: Inertia(inertia),
+            inverse_inertia: InverseInertia(inertia.recip()),
+            center_of_mass: CenterOfMass::default(),
+        }
+    }
+
+    // This is the actual collision detection part.
+    // It compute all contacts between two colliders at the given positions.
+    fn contact_manifolds(
+        &self,
+        other: &Self,
+        position1: Vector,
+        rotation1: impl Into<Rotation>,
+        position2: Vector,
+        rotation2: impl Into<Rotation>,
+        prediction_distance: Scalar,
+    ) -> Vec<ContactManifold> {
+        let rotation1: Rotation = rotation1.into();
+        let rotation2: Rotation = rotation2.into();
+
+        let inv_rotation1 = rotation1.inverse();
+        let delta_pos = inv_rotation1.rotate(position2 - position1);
+        let delta_rot = inv_rotation1.mul(rotation2);
+
+        let distance_squared = delta_pos.length_squared();
+        let sum_radius = self.radius + other.radius;
+
+        if distance_squared < (sum_radius + prediction_distance).powi(2) {
+            let normal1 = if distance_squared != 0.0 {
+                delta_pos.normalize_or_zero()
+            } else {
+                Vector::X
+            };
+            let normal2 = delta_rot.inverse().rotate(-normal1);
+            let point1 = normal1 * self.radius;
+            let point2 = normal2 * other.radius;
+
+            vec![ContactManifold {
+                index: 0,
+                normal1,
+                normal2,
+                contacts: vec![ContactData {
+                    index: 0,
+                    point1,
+                    point2,
+                    normal1,
+                    normal2,
+                    penetration: sum_radius - distance_squared.sqrt(),
+                    // Impulses are computed by the constraint solver
+                    normal_impulse: 0.0,
+                    tangent_impulse: 0.0,
+                }],
+            }]
+        } else {
+            vec![]
+        }
+    }
+}
+
+// Note: This circle collider only supports uniform scaling.
+impl ScalableCollider for CircleCollider {
+    fn scale(&self) -> Vector {
+        Vector::splat(self.scale)
+    }
+
+    fn set_scale(&mut self, scale: Vector, _detail: u32) {
+        // For non-unifprm scaling, this would need to be converted to an ellipse collider or a convex hull.
+        self.scale = scale.max_element();
+        self.radius = self.unscaled_radius * scale.max_element();
+    }
+}
+
+/// A marker component for the rotating body at the center.
+#[derive(Component)]
+struct CenterBody;
+
+fn setup(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) {
+    commands.spawn(Camera2dBundle::default());
+
+    let center_radius = 200.0;
+    let particle_radius = 5.0;
+
+    let red = materials.add(Color::rgb(0.9, 0.3, 0.3).into());
+    let blue = materials.add(Color::rgb(0.1, 0.6, 1.0).into());
+    let particle_mesh = meshes.add(shape::Circle::new(particle_radius).into());
+
+    // Spawn rotating body at the center.
+    commands
+        .spawn((
+            MaterialMesh2dBundle {
+                mesh: meshes.add(shape::Circle::new(center_radius).into()).into(),
+                material: materials.add(Color::rgb(0.7, 0.7, 0.8).into()).clone(),
+                ..default()
+            },
+            RigidBody::Kinematic,
+            CircleCollider::new(center_radius.adjust_precision()),
+            CenterBody,
+        ))
+        .with_children(|c| {
+            // Spawn obstacles along the perimeter of the rotating body, like the teeth of a cog.
+            let count = 8;
+            let angle_step = std::f32::consts::TAU / count as f32;
+            for i in 0..count {
+                let pos = Quat::from_rotation_z(i as f32 * angle_step) * Vec3::Y * center_radius;
+                c.spawn((
+                    MaterialMesh2dBundle {
+                        mesh: particle_mesh.clone().into(),
+                        material: red.clone(),
+                        transform: Transform::from_translation(pos).with_scale(Vec3::ONE * 5.0),
+                        ..default()
+                    },
+                    CircleCollider::new(particle_radius.adjust_precision()),
+                ));
+            }
+        });
+
+    let x_count = 10;
+    let y_count = 30;
+
+    // Spawm grid of particles. These will be pulled towards the rotating body.
+    for x in -x_count / 2..x_count / 2 {
+        for y in -y_count / 2..y_count / 2 {
+            commands.spawn((
+                MaterialMesh2dBundle {
+                    mesh: particle_mesh.clone().into(),
+                    material: blue.clone(),
+                    transform: Transform::from_xyz(
+                        x as f32 * 3.0 * particle_radius - 350.0,
+                        y as f32 * 3.0 * particle_radius,
+                        0.0,
+                    ),
+                    ..default()
+                },
+                RigidBody::Dynamic,
+                CircleCollider::new(particle_radius.adjust_precision()),
+                LinearDamping(0.4),
+            ));
+        }
+    }
+}
+
+/// Pulls all particles towards the center.
+fn center_gravity(
+    mut particles: Query<(&Transform, &mut LinearVelocity), Without<CenterBody>>,
+    time: Res<Time>,
+) {
+    let delta_seconds = time.delta_seconds_f64().adjust_precision();
+    for (transform, mut lin_vel) in &mut particles {
+        let pos_delta = transform.translation.truncate().adjust_precision();
+        let dir = -pos_delta.normalize_or_zero();
+        lin_vel.0 += 800.0 * delta_seconds * dir;
+    }
+}
+
+/// Rotates the center body periodically clockwise and counterclockwise.
+fn rotate(mut query: Query<&mut AngularVelocity, With<CenterBody>>, time: Res<Time>) {
+    let sin = 3.0 * time.elapsed_seconds_f64().adjust_precision().sin();
+    for mut ang_vel in &mut query {
+        ang_vel.0 = sin;
+    }
+}
diff --git a/src/components/mass_properties.rs b/src/components/mass_properties.rs
index 27187c73..0854f248 100644
--- a/src/components/mass_properties.rs
+++ b/src/components/mass_properties.rs
@@ -309,7 +309,7 @@ impl Default for ColliderDensity {
 ///
 /// fn print_collider_masses(query: Query<&ColliderMassProperties>) {
 ///     for mass_props in &query {
-///         println!("{}", mass_props.mass());
+///         println!("{}", mass_props.mass.0);
 ///     }
 /// }
 /// ```
@@ -318,15 +318,15 @@ impl Default for ColliderDensity {
 #[reflect(Component)]
 pub struct ColliderMassProperties {
     /// Mass given by collider.
-    pub(crate) mass: Mass,
+    pub mass: Mass,
     /// Inverse mass given by collider.
-    pub(crate) inverse_mass: InverseMass,
+    pub inverse_mass: InverseMass,
     /// Inertia given by collider.
-    pub(crate) inertia: Inertia,
+    pub inertia: Inertia,
     /// Inverse inertia given by collider.
-    pub(crate) inverse_inertia: InverseInertia,
+    pub inverse_inertia: InverseInertia,
     /// Local center of mass given by collider.
-    pub(crate) center_of_mass: CenterOfMass,
+    pub center_of_mass: CenterOfMass,
 }
 
 impl ColliderMassProperties {
@@ -339,68 +339,12 @@ impl ColliderMassProperties {
         center_of_mass: CenterOfMass::ZERO,
     };
 
-    /// Computes mass properties from a given [`Collider`] and density.
+    /// Computes mass properties from a given collider and density.
     ///
     /// Because [`ColliderMassProperties`] is read-only, adding this as a component manually
     /// has no effect. The mass properties will be recomputed using the [`ColliderDensity`].
-    pub fn new(collider: &Collider, density: Scalar) -> Self {
-        let props = collider.shape_scaled().mass_properties(density);
-
-        Self {
-            mass: Mass(props.mass()),
-            inverse_mass: InverseMass(props.inv_mass),
-
-            #[cfg(feature = "2d")]
-            inertia: Inertia(props.principal_inertia()),
-            #[cfg(feature = "3d")]
-            inertia: Inertia(props.reconstruct_inertia_matrix().into()),
-
-            #[cfg(feature = "2d")]
-            inverse_inertia: InverseInertia(1.0 / props.principal_inertia()),
-            #[cfg(feature = "3d")]
-            inverse_inertia: InverseInertia(props.reconstruct_inverse_inertia_matrix().into()),
-
-            center_of_mass: CenterOfMass(props.local_com.into()),
-        }
-    }
-
-    /// Get the [mass](Mass) of the [`Collider`].
-    pub fn mass(&self) -> Scalar {
-        self.mass.0
-    }
-
-    /// Get the [inverse mass](InverseMass) of the [`Collider`].
-    pub fn inverse_mass(&self) -> Scalar {
-        self.inverse_mass.0
-    }
-
-    /// Get the [inerta](Inertia) of the [`Collider`].
-    #[cfg(feature = "2d")]
-    pub fn inertia(&self) -> Scalar {
-        self.inertia.0
-    }
-
-    /// Get the [inertia tensor](InverseInertia) of the [`Collider`].
-    #[cfg(feature = "3d")]
-    pub fn inertia(&self) -> Matrix3 {
-        self.inertia.0
-    }
-
-    /// Get the [inverse inertia](InverseInertia) of the [`Collider`].
-    #[cfg(feature = "2d")]
-    pub fn inverse_inertia(&self) -> Scalar {
-        self.inverse_inertia.0
-    }
-
-    /// Get the [inverse inertia](InverseInertia) of the [`Collider`].
-    #[cfg(feature = "3d")]
-    pub fn inverse_inertia(&self) -> Matrix3 {
-        self.inverse_inertia.0
-    }
-
-    /// Get the [local center of mass](CenterOfMass) of the [`Collider`].
-    pub fn center_of_mass(&self) -> Vector {
-        self.center_of_mass.0
+    pub fn new<C: AnyCollider>(collider: &C, density: Scalar) -> Self {
+        collider.mass_properties(density)
     }
 }
 
diff --git a/src/components/mod.rs b/src/components/mod.rs
index 35aa755b..64e6382a 100644
--- a/src/components/mod.rs
+++ b/src/components/mod.rs
@@ -1,6 +1,5 @@
-//! Components used for rigid bodies, colliders and mass properties.
+//! Commonly used components.
 
-mod collider;
 mod forces;
 mod layers;
 mod locked_axes;
@@ -8,7 +7,6 @@ mod mass_properties;
 mod rotation;
 mod world_queries;
 
-pub use collider::*;
 pub use forces::*;
 pub use layers::*;
 pub use locked_axes::*;
diff --git a/src/components/rotation.rs b/src/components/rotation.rs
index 370821c8..57959b3b 100644
--- a/src/components/rotation.rs
+++ b/src/components/rotation.rs
@@ -146,7 +146,7 @@ impl Rotation {
         self.as_radians().to_degrees()
     }
 
-    /// Rotates the rotation by a given vector.
+    /// Rotates the given vector by `self`.
     pub fn rotate(&self, vec: Vector) -> Vector {
         Vector::new(
             vec.x * self.cos() - vec.y * self.sin(),
diff --git a/src/components/world_queries.rs b/src/components/world_queries.rs
index c415ca4f..e300ce27 100644
--- a/src/components/world_queries.rs
+++ b/src/components/world_queries.rs
@@ -93,7 +93,7 @@ impl<'w> RigidBodyQueryItem<'w> {
 
 #[derive(WorldQuery)]
 #[world_query(mutable)]
-pub(crate) struct MassPropertiesQuery {
+pub struct MassPropertiesQuery {
     pub mass: &'static mut Mass,
     pub inverse_mass: &'static mut InverseMass,
     pub inertia: &'static mut Inertia,
diff --git a/src/lib.rs b/src/lib.rs
index b8e78fa5..5a20cc64 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -536,7 +536,7 @@ pub mod prelude {
                 narrow_phase::NarrowPhaseConfig,
                 *,
             },
-            prepare::*,
+            prepare::{init_transforms, update_mass_properties, PrepareConfig, PreparePlugin},
             setup::*,
             solver::solve_constraint,
             spatial_query::*,
diff --git a/src/plugins/collision/broad_phase.rs b/src/plugins/collision/broad_phase.rs
index 49761d0c..0c00acc0 100644
--- a/src/plugins/collision/broad_phase.rs
+++ b/src/plugins/collision/broad_phase.rs
@@ -22,141 +22,52 @@ impl Plugin for BroadPhasePlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<AabbIntervals>();
 
+        app.configure_sets(
+            PhysicsSchedule,
+            (
+                BroadPhaseSet::First,
+                BroadPhaseSet::UpdateStructures,
+                BroadPhaseSet::CollectCollisions,
+                BroadPhaseSet::Last,
+            )
+                .chain()
+                .in_set(PhysicsStepSet::BroadPhase),
+        );
+
         let physics_schedule = app
             .get_schedule_mut(PhysicsSchedule)
             .expect("add PhysicsSchedule first");
 
         physics_schedule.add_systems(
-            (
-                update_aabb,
-                update_aabb_intervals,
-                add_new_aabb_intervals,
-                collect_collision_pairs,
-            )
+            (update_aabb_intervals, add_new_aabb_intervals)
                 .chain()
-                .in_set(PhysicsStepSet::BroadPhase),
+                .in_set(BroadPhaseSet::UpdateStructures),
         );
+
+        physics_schedule
+            .add_systems(collect_collision_pairs.in_set(BroadPhaseSet::CollectCollisions));
     }
 }
 
+/// System sets for systems running in [`PhysicsStepSet::BroadPhase`].
+#[derive(SystemSet, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum BroadPhaseSet {
+    /// Runs at the start of the broad phase. Empty by default.
+    First,
+    /// Updates acceleration structures and other data needed for broad phase collision detection.
+    UpdateStructures,
+    /// Detects potential intersections between entities and adds them to the [`BroadCollisionPairs`] resource.
+    CollectCollisions,
+    /// Runs at the end of the broad phase. Empty by default.
+    Last,
+}
+
 /// A list of entity pairs for potential collisions collected during the broad phase.
 #[derive(Reflect, Resource, Default, Debug)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[reflect(Resource)]
 pub struct BroadCollisionPairs(pub Vec<(Entity, Entity)>);
 
-type AABBChanged = Or<(
-    Changed<Position>,
-    Changed<Rotation>,
-    Changed<LinearVelocity>,
-    Changed<AngularVelocity>,
-    Changed<Collider>,
-)>;
-
-/// Updates the Axis-Aligned Bounding Boxes of all colliders. A safety margin will be added to account for sudden accelerations.
-#[allow(clippy::type_complexity)]
-fn update_aabb(
-    mut colliders: Query<
-        (
-            &Collider,
-            &mut ColliderAabb,
-            &Position,
-            &Rotation,
-            Option<&ColliderParent>,
-            Option<&LinearVelocity>,
-            Option<&AngularVelocity>,
-        ),
-        AABBChanged,
-    >,
-    parent_velocity: Query<
-        (&Position, Option<&LinearVelocity>, Option<&AngularVelocity>),
-        With<Children>,
-    >,
-    dt: Res<Time>,
-    narrow_phase_config: Option<Res<NarrowPhaseConfig>>,
-) {
-    // Safety margin multiplier bigger than DELTA_TIME to account for sudden accelerations
-    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) {
-            (*lin_vel, *ang_vel)
-        } else if let Some(Ok((parent_pos, Some(lin_vel), Some(ang_vel)))) =
-            collider_parent.map(|p| parent_velocity.get(p.get()))
-        {
-            // If the rigid body is rotating, off-center colliders will orbit around it,
-            // which affects their linear velocities. We need to compute the linear velocity
-            // at the offset position.
-            // TODO: This assumes that the colliders would continue moving in the same direction,
-            //       but because they are orbiting, the direction will change. We should take
-            //       into account the uniform circular motion.
-            let offset = pos.0 - parent_pos.0;
-            #[cfg(feature = "2d")]
-            let vel_at_offset =
-                lin_vel.0 + Vector::new(-ang_vel.0 * offset.y, ang_vel.0 * offset.x) * 1.0;
-            #[cfg(feature = "3d")]
-            let vel_at_offset = lin_vel.0 + ang_vel.cross(offset);
-            (LinearVelocity(vel_at_offset), *ang_vel)
-        } else {
-            (LinearVelocity::ZERO, AngularVelocity::ZERO)
-        };
-
-        // Compute current isometry and predicted isometry for next feame
-        let start_iso = utils::make_isometry(*pos, *rot);
-        let end_iso = {
-            #[cfg(feature = "2d")]
-            {
-                utils::make_isometry(
-                    pos.0 + lin_vel.0 * safety_margin_factor,
-                    *rot + Rotation::from_radians(safety_margin_factor * ang_vel.0),
-                )
-            }
-            #[cfg(feature = "3d")]
-            {
-                let q = Quaternion::from_vec4(ang_vel.0.extend(0.0)) * rot.0;
-                let (x, y, z, w) = (
-                    rot.x + safety_margin_factor * 0.5 * q.x,
-                    rot.y + safety_margin_factor * 0.5 * q.y,
-                    rot.z + safety_margin_factor * 0.5 * q.z,
-                    rot.w + safety_margin_factor * 0.5 * q.w,
-                );
-                utils::make_isometry(
-                    pos.0 + lin_vel.0 * safety_margin_factor,
-                    Quaternion::from_xyzw(x, y, z, w).normalize(),
-                )
-            }
-        };
-
-        // Compute swept AABB, the space that the body would occupy if it was integrated for one frame
-        aabb.0 = collider
-            .shape_scaled()
-            .compute_swept_aabb(&start_iso, &end_iso);
-
-        // Add narrow phase prediction distance to AABBs to avoid missed collisions
-        let prediction_distance = if let Some(ref config) = narrow_phase_config {
-            config.prediction_distance
-        } else {
-            #[cfg(feature = "2d")]
-            {
-                1.0
-            }
-            #[cfg(feature = "3d")]
-            {
-                0.005
-            }
-        };
-        aabb.maxs.x += prediction_distance;
-        aabb.mins.x -= prediction_distance;
-        aabb.maxs.y += prediction_distance;
-        aabb.mins.y -= prediction_distance;
-        #[cfg(feature = "3d")]
-        {
-            aabb.maxs.z += prediction_distance;
-            aabb.mins.z -= prediction_distance;
-        }
-    }
-}
-
 /// True if the rigid body hasn't moved.
 type IsBodyInactive = bool;
 
diff --git a/src/components/collider.rs b/src/plugins/collision/collider.rs
similarity index 91%
rename from src/components/collider.rs
rename to src/plugins/collision/collider.rs
index d711c2cc..4cd6d863 100644
--- a/src/components/collider.rs
+++ b/src/plugins/collision/collider.rs
@@ -14,7 +14,7 @@ use bevy::{
 use collision::contact_query::UnsupportedShape;
 use itertools::Either;
 use parry::{
-    bounding_volume::Aabb,
+    bounding_volume::{Aabb, BoundingVolume},
     shape::{RoundShape, SharedShape, TypedShape},
 };
 
@@ -26,6 +26,73 @@ pub type VHACDParameters = parry::transformation::vhacd::VHACDParameters;
 /// Flags used for the preprocessing of a triangle mesh collider.
 pub type TriMeshFlags = parry::shape::TriMeshFlags;
 
+/// A trait that generalizes over colliders. Implementing this trait
+/// allows colliders to be used with the physics engine.
+pub trait AnyCollider: Component {
+    /// Computes the [Axis-Aligned Bounding Box](ColliderAabb) of the collider
+    /// with the given position and rotation.
+    #[cfg_attr(
+        feature = "2d",
+        doc = "\n\nThe rotation is counterclockwise and in radians."
+    )]
+    fn aabb(&self, position: Vector, rotation: impl Into<Rotation>) -> ColliderAabb;
+
+    /// Computes the swept [Axis-Aligned Bounding Box](ColliderAabb) of the collider.
+    /// This corresponds to the space the shape would occupy if it moved from the given
+    /// start position to the given end position.
+    #[cfg_attr(
+        feature = "2d",
+        doc = "\n\nThe rotation is counterclockwise and in radians."
+    )]
+    fn swept_aabb(
+        &self,
+        start_position: Vector,
+        start_rotation: impl Into<Rotation>,
+        end_position: Vector,
+        end_rotation: impl Into<Rotation>,
+    ) -> ColliderAabb {
+        self.aabb(start_position, start_rotation)
+            .merged(self.aabb(end_position, end_rotation))
+    }
+
+    /// Computes the collider's mass properties based on its shape and a given density.
+    fn mass_properties(&self, density: Scalar) -> ColliderMassProperties;
+
+    /// Computes all [`ContactManifold`]s between two colliders.
+    ///
+    /// Returns an empty vector if the colliders are separated by a distance greater than `prediction_distance`
+    /// or if the given shapes are invalid.
+    fn contact_manifolds(
+        &self,
+        other: &Self,
+        position1: Vector,
+        rotation1: impl Into<Rotation>,
+        position2: Vector,
+        rotation2: impl Into<Rotation>,
+        prediction_distance: Scalar,
+    ) -> Vec<ContactManifold>;
+}
+
+/// A trait for colliders that support scaling.
+pub trait ScalableCollider: AnyCollider {
+    /// Returns the global scaling factor of the collider.
+    fn scale(&self) -> Vector;
+
+    /// Sets the global scaling factor of the collider.
+    ///
+    /// If the scaling factor is not uniform and the resulting scaled shape
+    /// can not be represented exactly, the given `detail` is used for an approximation.
+    fn set_scale(&mut self, scale: Vector, detail: u32);
+
+    /// Scales the collider by the given scaling factor.
+    ///
+    /// If the scaling factor is not uniform and the resulting scaled shape
+    /// can not be represented exactly, the given `detail` is used for an approximation.
+    fn scale_by(&mut self, factor: Vector, detail: u32) {
+        self.set_scale(factor * self.scale(), detail)
+    }
+}
+
 /// A collider used for detecting collisions and generating contacts.
 ///
 /// ## Creation
@@ -216,6 +283,66 @@ impl fmt::Debug for Collider {
     }
 }
 
+impl AnyCollider for Collider {
+    fn aabb(&self, position: Vector, rotation: impl Into<Rotation>) -> ColliderAabb {
+        ColliderAabb(
+            self.shape_scaled()
+                .compute_aabb(&utils::make_isometry(position, rotation)),
+        )
+    }
+
+    fn mass_properties(&self, density: Scalar) -> ColliderMassProperties {
+        let props = self.shape_scaled().mass_properties(density);
+
+        ColliderMassProperties {
+            mass: Mass(props.mass()),
+            inverse_mass: InverseMass(props.inv_mass),
+
+            #[cfg(feature = "2d")]
+            inertia: Inertia(props.principal_inertia()),
+            #[cfg(feature = "3d")]
+            inertia: Inertia(props.reconstruct_inertia_matrix().into()),
+
+            #[cfg(feature = "2d")]
+            inverse_inertia: InverseInertia(1.0 / props.principal_inertia()),
+            #[cfg(feature = "3d")]
+            inverse_inertia: InverseInertia(props.reconstruct_inverse_inertia_matrix().into()),
+
+            center_of_mass: CenterOfMass(props.local_com.into()),
+        }
+    }
+
+    fn contact_manifolds(
+        &self,
+        other: &Self,
+        position1: Vector,
+        rotation1: impl Into<Rotation>,
+        position2: Vector,
+        rotation2: impl Into<Rotation>,
+        prediction_distance: Scalar,
+    ) -> Vec<ContactManifold> {
+        contact_query::contact_manifolds(
+            self,
+            position1,
+            rotation1,
+            other,
+            position2,
+            rotation2,
+            prediction_distance,
+        )
+    }
+}
+
+impl ScalableCollider for Collider {
+    fn scale(&self) -> Vector {
+        self.scale()
+    }
+
+    fn set_scale(&mut self, scale: Vector, detail: u32) {
+        self.set_scale(scale, detail)
+    }
+}
+
 impl Collider {
     /// Returns the raw unscaled shape of the collider.
     pub fn shape(&self) -> &SharedShape {
@@ -227,11 +354,6 @@ impl Collider {
         &self.scaled_shape
     }
 
-    /// Returns the global scale of the collider.
-    pub fn scale(&self) -> Vector {
-        self.scale
-    }
-
     /// Sets the unscaled shape of the collider. The collider's scale will be applied to this shape.
     pub fn set_shape(&mut self, shape: SharedShape) {
         self.shape = shape;
@@ -244,6 +366,11 @@ impl Collider {
         }
     }
 
+    /// Returns the global scale of the collider.
+    pub fn scale(&self) -> Vector {
+        self.scale
+    }
+
     /// Set the global scaling factor of this shape.
     ///
     /// If the scaling factor is not uniform, and the scaled shape can’t be
@@ -271,29 +398,6 @@ impl Collider {
         }
     }
 
-    /// Computes the [Axis-Aligned Bounding Box](ColliderAabb) of the collider.
-    #[cfg(feature = "2d")]
-    pub fn compute_aabb(&self, position: Vector, rotation: Scalar) -> ColliderAabb {
-        ColliderAabb(self.shape_scaled().compute_aabb(&utils::make_isometry(
-            position,
-            Rotation::from_radians(rotation),
-        )))
-    }
-
-    /// Computes the [Axis-Aligned Bounding Box](ColliderAabb) of the collider.
-    #[cfg(feature = "3d")]
-    pub fn compute_aabb(&self, position: Vector, rotation: Quaternion) -> ColliderAabb {
-        ColliderAabb(
-            self.shape_scaled()
-                .compute_aabb(&utils::make_isometry(position, Rotation(rotation))),
-        )
-    }
-
-    /// Computes the collider's mass properties based on its shape and a given density.
-    pub fn mass_properties(&self, density: Scalar) -> ColliderMassProperties {
-        ColliderMassProperties::new(self, density)
-    }
-
     /// Projects the given `point` onto `self` transformed by `translation` and `rotation`.
     /// The returned tuple contains the projected point and whether it is inside the collider.
     ///
@@ -1287,10 +1391,20 @@ pub struct Sensor;
 pub struct ColliderAabb(pub Aabb);
 
 impl ColliderAabb {
-    /// Creates a new collider from a given [`SharedShape`] with a default density of 1.0.
+    /// Creates a new [`ColliderAabb`] from the given `center` and `half_size`.
+    pub fn new(center: Vector, half_size: Vector) -> Self {
+        Self(Aabb::from_half_extents(center.into(), half_size.into()))
+    }
+
+    /// Creates a new [`ColliderAabb`] from a given [`SharedShape`].
     pub fn from_shape(shape: &SharedShape) -> Self {
         Self(shape.compute_local_aabb())
     }
+
+    /// Merges this AABB with another one.
+    pub fn merged(self, other: Self) -> Self {
+        ColliderAabb(self.0.merged(&other.0))
+    }
 }
 
 impl Default for ColliderAabb {
diff --git a/src/plugins/collision/collider_backend.rs b/src/plugins/collision/collider_backend.rs
new file mode 100644
index 00000000..469b2f59
--- /dev/null
+++ b/src/plugins/collision/collider_backend.rs
@@ -0,0 +1,884 @@
+//! Handles generic collider backend logic, like initializing colliders and AABBs and updating related components.
+//!
+//! See [`ColliderBackendPlugin`].
+
+use std::marker::PhantomData;
+
+use crate::{
+    broad_phase::BroadPhaseSet,
+    prelude::*,
+    prepare::{any_new, PrepareSet},
+    sync::SyncSet,
+};
+#[cfg(all(feature = "3d", feature = "async-collider"))]
+use bevy::scene::SceneInstance;
+use bevy::{
+    prelude::*,
+    utils::{intern::Interned, HashMap},
+};
+
+/// A plugin for handling generic collider backend logic.
+///
+/// - Initializes colliders.
+/// - Updates [`ColliderAabb`]s.
+/// - Updates [`ColliderParent`]s.
+/// - Updates collider mass properties.
+/// - Updates collider scale based on `Transform` scale.
+/// - Propagates child collider positions.
+///
+/// ## Custom collision backends
+///
+/// By default, [`PhysicsPlugins`] adds this plugin for the [`Collider`] component.
+/// You can also create custom collider backends by implementing the [`AnyCollider`] and [`ScalableCollider`] traits.
+///
+/// To use a custom collider backend, simply add the [`ColliderBackendPlugin`] with your collider type:
+///
+/// ```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::*;")]
+/// #
+/// # type MyCollider = Collider;
+///
+/// fn main() {
+///     App::new()
+///         .add_plugins((
+///             DefaultPlugins,
+///             PhysicsPlugins::default(),
+///             // MyCollider must implement AnyCollider and ScalableCollider.
+///             ColliderBackendPlugin::<MyCollider>::default(),
+///             // To enable collision detection for the collider,
+///             // we also need to add the NarrowPhasePlugin for it.
+///             NarrowPhasePlugin::<MyCollider>::default(),
+///         ))
+///         // ...your other plugins, systems and resources
+///         .run();
+/// }
+/// ```
+///
+/// Assuming you have implemented [`AnyCollider`] and [`ScalableCollider`] correctly,
+/// it should now work with the rest of the engine just like normal [`Collider`]s!
+///
+/// **Note**: [Spatial queries](spatial_query) are not supported for custom colliders yet.
+
+pub struct ColliderBackendPlugin<C: ScalableCollider> {
+    schedule: Interned<dyn ScheduleLabel>,
+    _phantom: PhantomData<C>,
+}
+
+impl<C: ScalableCollider> ColliderBackendPlugin<C> {
+    /// Creates a [`ColliderBackendPlugin`] with the schedule that is used for running the [`PhysicsSchedule`].
+    ///
+    /// The default schedule is `PostUpdate`.
+    pub fn new(schedule: impl ScheduleLabel) -> Self {
+        Self {
+            schedule: schedule.intern(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<C: ScalableCollider> Default for ColliderBackendPlugin<C> {
+    fn default() -> Self {
+        Self {
+            schedule: PostUpdate.intern(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<C: ScalableCollider> Plugin for ColliderBackendPlugin<C> {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<ColliderStorageMap<C>>();
+
+        app.add_systems(
+            self.schedule,
+            (
+                (
+                    init_colliders::<C>,
+                    apply_deferred,
+                    update_collider_parents::<C>,
+                    apply_deferred,
+                )
+                    .chain()
+                    .in_set(PrepareSet::InitColliders),
+                init_transforms::<C>
+                    .in_set(PrepareSet::InitTransforms)
+                    .after(init_transforms::<RigidBody>),
+                (
+                    (
+                        propagate_collider_transforms,
+                        update_child_collider_position,
+                    )
+                        .chain()
+                        .run_if(any_new::<C>),
+                    update_collider_mass_properties::<C>,
+                )
+                    .chain()
+                    .in_set(PrepareSet::Finalize)
+                    .before(prepare::update_mass_properties),
+                update_collider_scale::<C>
+                    .after(SyncSet::Update)
+                    .before(SyncSet::Last),
+            ),
+        );
+
+        let physics_schedule = app
+            .get_schedule_mut(PhysicsSchedule)
+            .expect("add PhysicsSchedule first");
+
+        // Allowing ambiguities is required so that it's possible
+        // to have multiple collision backends at the same time.
+        physics_schedule.add_systems(
+            update_aabb::<C>
+                .in_set(PhysicsStepSet::BroadPhase)
+                .after(BroadPhaseSet::First)
+                .before(BroadPhaseSet::UpdateStructures)
+                .ambiguous_with_all(),
+        );
+
+        physics_schedule.add_systems((
+            update_collider_storage::<C>.before(PhysicsStepSet::BroadPhase),
+            handle_collider_storage_removals::<C>.after(PhysicsStepSet::SpatialQuery),
+            handle_rigid_body_removals.after(PhysicsStepSet::SpatialQuery),
+        ));
+
+        physics_schedule.add_systems(
+            wake_on_collider_removed::<C>
+                .in_set(PhysicsStepSet::Sleeping)
+                .after(sleeping::mark_sleeping_bodies)
+                .before(sleeping::wake_on_changed)
+                // Allowing ambiguities is required so that it's possible
+                // to have multiple collision backends at the same time.
+                .ambiguous_with_all(),
+        );
+
+        #[cfg(all(feature = "3d", feature = "async-collider"))]
+        app.add_systems(Update, (init_async_colliders, init_async_scene_colliders));
+
+        // Update child colliders before narrow phase in substepping loop
+        let substep_schedule = app
+            .get_schedule_mut(SubstepSchedule)
+            .expect("add SubstepSchedule first");
+        substep_schedule.add_systems(
+            (
+                propagate_collider_transforms,
+                update_child_collider_position,
+            )
+                .chain()
+                .after(SubstepSet::Integrate)
+                .before(SubstepSet::NarrowPhase)
+                .ambiguous_with_all(),
+        );
+    }
+}
+
+#[derive(Reflect, Clone, Copy, Component, Debug, Default, Deref, DerefMut, PartialEq)]
+#[reflect(Component)]
+pub(crate) struct PreviousColliderTransform(ColliderTransform);
+
+// TODO: Remove this once component removal hooks exist
+/// A hash map that stores some collider data that is needed when colliders are removed from
+/// rigid bodies.
+///
+/// This includes the collider parent for finding the associated rigid body after collider removal,
+/// and collider mass properties for updating the rigid body's mass properties when its collider is removed.
+///
+/// Ideally, we would just have some entity removal event or callback, but that doesn't
+/// exist yet, and `RemovedComponents` only returns entities, not component data.
+#[derive(Resource, Reflect, Clone, Debug, PartialEq)]
+#[reflect(Resource)]
+pub(crate) struct ColliderStorageMap<C: AnyCollider> {
+    pub(crate) map: HashMap<Entity, (ColliderParent, ColliderMassProperties, ColliderTransform)>,
+    _phantom: PhantomData<C>,
+}
+
+impl<C: AnyCollider> Default for ColliderStorageMap<C> {
+    fn default() -> Self {
+        Self {
+            map: default(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+/// Initializes missing components for [colliders](Collider).
+#[allow(clippy::type_complexity)]
+fn init_colliders<C: AnyCollider>(
+    mut commands: Commands,
+    mut colliders: Query<
+        (
+            Entity,
+            &C,
+            Option<&ColliderAabb>,
+            Option<&ColliderDensity>,
+            Option<&ColliderMassProperties>,
+        ),
+        Added<C>,
+    >,
+) {
+    for (entity, collider, aabb, density, mass_properties) in &mut colliders {
+        let density = *density.unwrap_or(&ColliderDensity::default());
+        commands.entity(entity).insert((
+            *aabb.unwrap_or(&collider.aabb(Vector::ZERO, Rotation::default())),
+            density,
+            *mass_properties.unwrap_or(&collider.mass_properties(density.0)),
+            CollidingEntities::default(),
+        ));
+    }
+}
+
+/// Creates [`Collider`]s from [`AsyncCollider`]s if the meshes have become available.
+#[cfg(all(feature = "3d", feature = "async-collider"))]
+pub fn init_async_colliders(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    async_colliders: Query<(Entity, &Handle<Mesh>, &AsyncCollider)>,
+) {
+    for (entity, mesh_handle, async_collider) in async_colliders.iter() {
+        if let Some(mesh) = meshes.get(mesh_handle) {
+            let collider = match &async_collider.0 {
+                ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
+                ComputedCollider::TriMeshWithFlags(flags) => {
+                    Collider::trimesh_from_mesh_with_config(mesh, *flags)
+                }
+                ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
+                ComputedCollider::ConvexDecomposition(params) => {
+                    Collider::convex_decomposition_from_mesh_with_config(mesh, params)
+                }
+            };
+            if let Some(collider) = collider {
+                commands
+                    .entity(entity)
+                    .insert(collider)
+                    .remove::<AsyncCollider>();
+            } else {
+                error!("Unable to generate collider from mesh {:?}", mesh);
+            }
+        }
+    }
+}
+
+/// Creates [`Collider`]s from [`AsyncSceneCollider`]s if the scenes have become available.
+#[cfg(all(feature = "3d", feature = "async-collider"))]
+pub fn init_async_scene_colliders(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    scene_spawner: Res<SceneSpawner>,
+    async_colliders: Query<(Entity, &SceneInstance, &AsyncSceneCollider)>,
+    children: Query<&Children>,
+    mesh_handles: Query<(&Name, &Handle<Mesh>)>,
+) {
+    for (scene_entity, scene_instance, async_scene_collider) in async_colliders.iter() {
+        if scene_spawner.instance_is_ready(**scene_instance) {
+            for child_entity in children.iter_descendants(scene_entity) {
+                if let Ok((name, handle)) = mesh_handles.get(child_entity) {
+                    let Some(collider_data) = async_scene_collider
+                        .meshes_by_name
+                        .get(name.as_str())
+                        .cloned()
+                        .unwrap_or(
+                            async_scene_collider
+                                .default_shape
+                                .clone()
+                                .map(|shape| AsyncSceneColliderData { shape, ..default() }),
+                        )
+                    else {
+                        continue;
+                    };
+
+                    let mesh = meshes.get(handle).expect("mesh should already be loaded");
+
+                    let collider = match collider_data.shape {
+                        ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
+                        ComputedCollider::TriMeshWithFlags(flags) => {
+                            Collider::trimesh_from_mesh_with_config(mesh, flags)
+                        }
+                        ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
+                        ComputedCollider::ConvexDecomposition(params) => {
+                            Collider::convex_decomposition_from_mesh_with_config(mesh, &params)
+                        }
+                    };
+                    if let Some(collider) = collider {
+                        commands.entity(child_entity).insert((
+                            collider,
+                            collider_data.layers,
+                            ColliderDensity(collider_data.density),
+                        ));
+                    } else {
+                        error!(
+                            "unable to generate collider from mesh {:?} with name {}",
+                            mesh, name
+                        );
+                    }
+                }
+            }
+
+            commands.entity(scene_entity).remove::<AsyncSceneCollider>();
+        }
+    }
+}
+
+/// Updates the Axis-Aligned Bounding Boxes of all colliders. A safety margin will be added to account for sudden accelerations.
+#[allow(clippy::type_complexity)]
+fn update_aabb<C: AnyCollider>(
+    mut colliders: Query<
+        (
+            &C,
+            &mut ColliderAabb,
+            &Position,
+            &Rotation,
+            Option<&ColliderParent>,
+            Option<&LinearVelocity>,
+            Option<&AngularVelocity>,
+        ),
+        Or<(
+            Changed<Position>,
+            Changed<Rotation>,
+            Changed<LinearVelocity>,
+            Changed<AngularVelocity>,
+            Changed<C>,
+        )>,
+    >,
+    parent_velocity: Query<
+        (&Position, Option<&LinearVelocity>, Option<&AngularVelocity>),
+        With<Children>,
+    >,
+    dt: Res<Time>,
+    narrow_phase_config: Option<Res<NarrowPhaseConfig>>,
+) {
+    // Safety margin multiplier bigger than DELTA_TIME to account for sudden accelerations
+    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) {
+            (*lin_vel, *ang_vel)
+        } else if let Some(Ok((parent_pos, Some(lin_vel), Some(ang_vel)))) =
+            collider_parent.map(|p| parent_velocity.get(p.get()))
+        {
+            // If the rigid body is rotating, off-center colliders will orbit around it,
+            // which affects their linear velocities. We need to compute the linear velocity
+            // at the offset position.
+            // TODO: This assumes that the colliders would continue moving in the same direction,
+            //       but because they are orbiting, the direction will change. We should take
+            //       into account the uniform circular motion.
+            let offset = pos.0 - parent_pos.0;
+            #[cfg(feature = "2d")]
+            let vel_at_offset =
+                lin_vel.0 + Vector::new(-ang_vel.0 * offset.y, ang_vel.0 * offset.x) * 1.0;
+            #[cfg(feature = "3d")]
+            let vel_at_offset = lin_vel.0 + ang_vel.cross(offset);
+            (LinearVelocity(vel_at_offset), *ang_vel)
+        } else {
+            (LinearVelocity::ZERO, AngularVelocity::ZERO)
+        };
+
+        // Current position and predicted position for next feame
+        let (start_pos, start_rot) = (*pos, *rot);
+        let (end_pos, end_rot) = {
+            #[cfg(feature = "2d")]
+            {
+                (
+                    pos.0 + lin_vel.0 * safety_margin_factor,
+                    *rot + Rotation::from_radians(safety_margin_factor * ang_vel.0),
+                )
+            }
+            #[cfg(feature = "3d")]
+            {
+                let q = Quaternion::from_vec4(ang_vel.0.extend(0.0)) * rot.0;
+                let (x, y, z, w) = (
+                    rot.x + safety_margin_factor * 0.5 * q.x,
+                    rot.y + safety_margin_factor * 0.5 * q.y,
+                    rot.z + safety_margin_factor * 0.5 * q.z,
+                    rot.w + safety_margin_factor * 0.5 * q.w,
+                );
+                (
+                    pos.0 + lin_vel.0 * safety_margin_factor,
+                    Quaternion::from_xyzw(x, y, z, w).normalize(),
+                )
+            }
+        };
+
+        // Compute swept AABB, the space that the body would occupy if it was integrated for one frame
+        aabb.0 = *collider.swept_aabb(start_pos.0, start_rot, end_pos, end_rot);
+
+        // Add narrow phase prediction distance to AABBs to avoid missed collisions
+        let prediction_distance = if let Some(ref config) = narrow_phase_config {
+            config.prediction_distance
+        } else {
+            #[cfg(feature = "2d")]
+            {
+                1.0
+            }
+            #[cfg(feature = "3d")]
+            {
+                0.005
+            }
+        };
+        aabb.maxs.x += prediction_distance;
+        aabb.mins.x -= prediction_distance;
+        aabb.maxs.y += prediction_distance;
+        aabb.mins.y -= prediction_distance;
+        #[cfg(feature = "3d")]
+        {
+            aabb.maxs.z += prediction_distance;
+            aabb.mins.z -= prediction_distance;
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+fn update_collider_parents<C: AnyCollider>(
+    mut commands: Commands,
+    mut bodies: Query<(Entity, Option<&mut ColliderParent>, Has<C>), With<RigidBody>>,
+    children: Query<&Children>,
+    mut child_colliders: Query<Option<&mut ColliderParent>, (With<C>, Without<RigidBody>)>,
+) {
+    for (entity, collider_parent, has_collider) in &mut bodies {
+        if has_collider {
+            if let Some(mut collider_parent) = collider_parent {
+                collider_parent.0 = entity;
+            } else {
+                commands.entity(entity).insert((
+                    ColliderParent(entity),
+                    // Todo: This probably causes a one frame delay. Compute real value?
+                    ColliderTransform::default(),
+                    PreviousColliderTransform::default(),
+                ));
+            }
+        }
+        for child in children.iter_descendants(entity) {
+            if let Ok(collider_parent) = child_colliders.get_mut(child) {
+                if let Some(mut collider_parent) = collider_parent {
+                    collider_parent.0 = entity;
+                } else {
+                    commands.entity(child).insert((
+                        ColliderParent(entity),
+                        // Todo: This probably causes a one frame delay. Compute real value?
+                        ColliderTransform::default(),
+                        PreviousColliderTransform::default(),
+                    ));
+                }
+            }
+        }
+    }
+}
+
+/// Updates colliders when the rigid bodies they were attached to have been removed.
+fn handle_rigid_body_removals(
+    mut commands: Commands,
+    colliders: Query<(Entity, &ColliderParent), Without<RigidBody>>,
+    bodies: Query<(), With<RigidBody>>,
+    removals: RemovedComponents<RigidBody>,
+) {
+    // Return if no rigid bodies have been removed
+    if removals.is_empty() {
+        return;
+    }
+
+    for (collider_entity, collider_parent) in &colliders {
+        // If the body associated with the collider parent entity doesn't exist,
+        // remove ColliderParent and ColliderTransform.
+        if !bodies.contains(collider_parent.get()) {
+            commands.entity(collider_entity).remove::<(
+                ColliderParent,
+                ColliderTransform,
+                PreviousColliderTransform,
+            )>();
+        }
+    }
+}
+
+/// Updates [`ColliderStorageMap`], a resource that stores some collider properties that need
+/// to be handled when colliders are removed from entities.
+#[allow(clippy::type_complexity)]
+fn update_collider_storage<C: AnyCollider>(
+    // TODO: Maybe it's enough to store only colliders that aren't on rigid body entities
+    //       directly (i.e. child colliders)
+    colliders: Query<
+        (
+            Entity,
+            &ColliderParent,
+            &ColliderMassProperties,
+            &ColliderTransform,
+        ),
+        Or<(
+            Changed<ColliderParent>,
+            Changed<ColliderTransform>,
+            Changed<ColliderMassProperties>,
+        )>,
+    >,
+    mut storage: ResMut<ColliderStorageMap<C>>,
+) {
+    for (entity, parent, collider_mass_properties, collider_transform) in &colliders {
+        storage.map.insert(
+            entity,
+            (*parent, *collider_mass_properties, *collider_transform),
+        );
+    }
+}
+
+/// Removes removed colliders from the [`ColliderStorageMap`] resource at the end of the physics frame.
+fn handle_collider_storage_removals<C: AnyCollider>(
+    mut removals: RemovedComponents<C>,
+    mut storage: ResMut<ColliderStorageMap<C>>,
+) {
+    removals.read().for_each(|entity| {
+        storage.map.remove(&entity);
+    });
+}
+
+#[allow(clippy::type_complexity)]
+pub(crate) fn update_child_collider_position(
+    mut colliders: Query<
+        (
+            &ColliderTransform,
+            &mut Position,
+            &mut Rotation,
+            &ColliderParent,
+        ),
+        Without<RigidBody>,
+    >,
+    parents: Query<(&Position, &Rotation), (With<RigidBody>, With<Children>)>,
+) {
+    for (collider_transform, mut position, mut rotation, parent) in &mut colliders {
+        let Ok((parent_pos, parent_rot)) = parents.get(parent.get()) else {
+            continue;
+        };
+
+        position.0 = parent_pos.0 + parent_rot.rotate(collider_transform.translation);
+        #[cfg(feature = "2d")]
+        {
+            *rotation = *parent_rot + collider_transform.rotation;
+        }
+        #[cfg(feature = "3d")]
+        {
+            *rotation = (parent_rot.0 * collider_transform.rotation.0)
+                .normalize()
+                .into();
+        }
+    }
+}
+
+/// Updates the scale of colliders based on [`Transform`] scale.
+#[allow(clippy::type_complexity)]
+pub fn update_collider_scale<C: ScalableCollider>(
+    mut colliders: ParamSet<(
+        // Root bodies
+        Query<(&Transform, &mut C), Without<Parent>>,
+        // Child colliders
+        Query<(&ColliderTransform, &mut C), With<Parent>>,
+    )>,
+) {
+    // Update collider scale for root bodies
+    for (transform, mut collider) in &mut colliders.p0() {
+        #[cfg(feature = "2d")]
+        let scale = transform.scale.truncate().adjust_precision();
+        #[cfg(feature = "3d")]
+        let scale = transform.scale.adjust_precision();
+        if scale != collider.scale() {
+            // TODO: Support configurable subdivision count for shapes that
+            //       can't be represented without approximations after scaling.
+            collider.set_scale(scale, 10);
+        }
+    }
+
+    // Update collider scale for child colliders
+    for (collider_transform, mut collider) in &mut colliders.p1() {
+        if collider_transform.scale != collider.scale() {
+            // TODO: Support configurable subdivision count for shapes that
+            //       can't be represented without approximations after scaling.
+            collider.set_scale(collider_transform.scale, 10);
+        }
+    }
+}
+
+/// Updates [`ColliderTransform`]s based on entity hierarchies. Each transform is computed by recursively
+/// traversing the children of each rigid body and adding their transforms together to form
+/// the total transform relative to the body.
+///
+/// This is largely a clone of `propagate_transforms` in `bevy_transform`.
+#[allow(clippy::type_complexity)]
+pub(crate) fn propagate_collider_transforms(
+    mut root_query: Query<(Entity, Ref<Transform>, &Children), Without<Parent>>,
+    collider_query: Query<
+        (
+            Ref<Transform>,
+            Option<&mut ColliderTransform>,
+            Option<&Children>,
+        ),
+        With<Parent>,
+    >,
+    parent_query: Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
+) {
+    root_query.par_iter_mut().for_each(
+        |(entity, transform,children)| {
+            for (child, child_transform, is_child_rb, parent) in parent_query.iter_many(children) {
+                assert_eq!(
+                    parent.get(), entity,
+                    "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
+                );
+                let child_transform = ColliderTransform::from(*child_transform);
+
+                // SAFETY:
+                // - `child` must have consistent parentage, or the above assertion would panic.
+                // Since `child` is parented to a root entity, the entire hierarchy leading to it is consistent.
+                // - We may operate as if all descendants are consistent, since `propagate_collider_transform_recursive` will panic before 
+                //   continuing to propagate if it encounters an entity with inconsistent parentage.
+                // - Since each root entity is unique and the hierarchy is consistent and forest-like,
+                //   other root entities' `propagate_collider_transform_recursive` calls will not conflict with this one.
+                // - Since this is the only place where `transform_query` gets used, there will be no conflicting fetches elsewhere.
+                unsafe {
+                    propagate_collider_transforms_recursive(
+                        if is_child_rb {
+                            ColliderTransform {
+                                scale: child_transform.scale,
+                                ..default()
+                            }
+                        } else {
+                            let transform = ColliderTransform::from(*transform);
+
+                            ColliderTransform {
+                                translation: transform.scale * child_transform.translation,
+                                rotation: child_transform.rotation,
+                                scale: (transform.scale * child_transform.scale).max(Vector::splat(Scalar::EPSILON)),
+                            }
+                        },
+                        &collider_query,
+                        &parent_query,
+                        child,
+                        transform.is_changed() || parent.is_changed()
+                    );
+                }
+            }
+        },
+    );
+}
+
+/// Recursively computes the [`ColliderTransform`] for `entity` and all of its descendants
+/// by propagating transforms.
+///
+/// This is largely a clone of `propagate_recursive` in `bevy_transform`.
+///
+/// # Panics
+///
+/// If `entity`'s descendants have a malformed hierarchy, this function will panic occur before propagating
+/// the transforms of any malformed entities and their descendants.
+///
+/// # Safety
+///
+/// - While this function is running, `transform_query` must not have any fetches for `entity`,
+/// nor any of its descendants.
+/// - The caller must ensure that the hierarchy leading to `entity`
+/// is well-formed and must remain as a tree or a forest. Each entity must have at most one parent.
+#[allow(clippy::type_complexity)]
+unsafe fn propagate_collider_transforms_recursive(
+    transform: ColliderTransform,
+    collider_query: &Query<
+        (
+            Ref<Transform>,
+            Option<&mut ColliderTransform>,
+            Option<&Children>,
+        ),
+        With<Parent>,
+    >,
+    parent_query: &Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
+    entity: Entity,
+    mut changed: bool,
+) {
+    let children = {
+        // SAFETY: This call cannot create aliased mutable references.
+        //   - The top level iteration parallelizes on the roots of the hierarchy.
+        //   - The caller ensures that each child has one and only one unique parent throughout the entire
+        //     hierarchy.
+        //
+        // For example, consider the following malformed hierarchy:
+        //
+        //     A
+        //   /   \
+        //  B     C
+        //   \   /
+        //     D
+        //
+        // D has two parents, B and C. If the propagation passes through C, but the Parent component on D points to B,
+        // the above check will panic as the origin parent does match the recorded parent.
+        //
+        // Also consider the following case, where A and B are roots:
+        //
+        //  A       B
+        //   \     /
+        //    C   D
+        //     \ /
+        //      E
+        //
+        // Even if these A and B start two separate tasks running in parallel, one of them will panic before attempting
+        // to mutably access E.
+        let Ok((transform_ref, collider_transform, children)) =
+            (unsafe { collider_query.get_unchecked(entity) })
+        else {
+            return;
+        };
+
+        changed |= transform_ref.is_changed();
+        if changed {
+            if let Some(mut collider_transform) = collider_transform {
+                if *collider_transform != transform {
+                    *collider_transform = transform;
+                }
+            }
+        }
+
+        children
+    };
+
+    let Some(children) = children else { return };
+    for (child, child_transform, is_rb, parent) in parent_query.iter_many(children) {
+        assert_eq!(
+            parent.get(), entity,
+            "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
+        );
+
+        let child_transform = ColliderTransform::from(*child_transform);
+
+        // SAFETY: The caller guarantees that `transform_query` will not be fetched
+        // for any descendants of `entity`, so it is safe to call `propagate_collider_transforms_recursive` for each child.
+        //
+        // The above assertion ensures that each child has one and only one unique parent throughout the
+        // entire hierarchy.
+        unsafe {
+            propagate_collider_transforms_recursive(
+                if is_rb {
+                    ColliderTransform {
+                        scale: child_transform.scale,
+                        ..default()
+                    }
+                } else {
+                    ColliderTransform {
+                        translation: transform.transform_point(child_transform.translation),
+                        #[cfg(feature = "2d")]
+                        rotation: transform.rotation + child_transform.rotation,
+                        #[cfg(feature = "3d")]
+                        rotation: Rotation(transform.rotation.0 * child_transform.rotation.0),
+                        scale: (transform.scale * child_transform.scale)
+                            .max(Vector::splat(Scalar::EPSILON)),
+                    }
+                },
+                collider_query,
+                parent_query,
+                child,
+                changed || parent.is_changed(),
+            );
+        }
+    }
+}
+
+/// Updates the mass properties of [`Collider`]s and [collider parents](ColliderParent).
+#[allow(clippy::type_complexity)]
+fn update_collider_mass_properties<C: AnyCollider>(
+    mut mass_props: Query<(Entity, MassPropertiesQuery)>,
+    mut colliders: Query<
+        (
+            &ColliderTransform,
+            &mut PreviousColliderTransform,
+            &ColliderParent,
+            Ref<C>,
+            &ColliderDensity,
+            &mut ColliderMassProperties,
+        ),
+        Or<(
+            Changed<C>,
+            Changed<ColliderTransform>,
+            Changed<ColliderDensity>,
+            Changed<ColliderMassProperties>,
+        )>,
+    >,
+    collider_map: Res<ColliderStorageMap<C>>,
+    mut removed_colliders: RemovedComponents<C>,
+) {
+    for (
+        collider_transform,
+        mut previous_collider_transform,
+        collider_parent,
+        collider,
+        density,
+        mut collider_mass_properties,
+    ) in &mut colliders
+    {
+        if let Ok((_, mut mass_properties)) = mass_props.get_mut(collider_parent.0) {
+            // Subtract previous collider mass props from the body's own mass props,
+            // If the collider is new, it doesn't have previous mass props, so we shouldn't subtract anything.
+            if !collider.is_added() {
+                mass_properties -= ColliderMassProperties {
+                    center_of_mass: CenterOfMass(
+                        previous_collider_transform
+                            .transform_point(collider_mass_properties.center_of_mass.0),
+                    ),
+                    ..*collider_mass_properties
+                };
+            }
+
+            previous_collider_transform.0 = *collider_transform;
+
+            // Update collider mass props
+            *collider_mass_properties = collider.mass_properties(density.max(Scalar::EPSILON));
+
+            // Add new collider mass props to the body's mass props
+            mass_properties += ColliderMassProperties {
+                center_of_mass: CenterOfMass(
+                    collider_transform.transform_point(collider_mass_properties.center_of_mass.0),
+                ),
+                ..*collider_mass_properties
+            };
+        }
+    }
+
+    // Subtract mass properties of removed colliders
+    for entity in removed_colliders.read() {
+        if let Some((collider_parent, collider_mass_properties, collider_transform)) =
+            collider_map.map.get(&entity)
+        {
+            if let Ok((_, mut mass_properties)) = mass_props.get_mut(collider_parent.0) {
+                mass_properties -= ColliderMassProperties {
+                    center_of_mass: CenterOfMass(
+                        collider_transform
+                            .transform_point(collider_mass_properties.center_of_mass.0),
+                    ),
+                    ..*collider_mass_properties
+                };
+            }
+        }
+    }
+}
+
+/// Removes the [`Sleeping`] component from sleeping bodies when any of their
+/// colliders have been removed.
+#[allow(clippy::type_complexity)]
+fn wake_on_collider_removed<C: AnyCollider>(
+    mut commands: Commands,
+    mut bodies: Query<(Entity, &mut TimeSleeping), With<RigidBody>>,
+    all_colliders: Query<&ColliderParent>,
+    child_colliders: Query<
+        &ColliderParent,
+        (
+            Without<RigidBody>,
+            Or<(Changed<C>, Changed<Transform>, Changed<ColliderTransform>)>,
+        ),
+    >,
+    mut removed_colliders: RemovedComponents<C>,
+    // This stores some collider data so that we can access it even though the entity has been removed
+    collider_storage: Res<ColliderStorageMap<C>>,
+) {
+    let removed_colliders_iter =
+        all_colliders.iter_many(removed_colliders.read().filter_map(|entity| {
+            collider_storage
+                .map
+                .get(&entity)
+                .map(|(rb_entity, _, _)| rb_entity.get())
+        }));
+    for collider_parent in child_colliders.iter().chain(removed_colliders_iter) {
+        if let Ok((entity, mut time_sleeping)) = bodies.get_mut(collider_parent.get()) {
+            commands.entity(entity).remove::<Sleeping>();
+            time_sleeping.0 = 0.0;
+        }
+    }
+}
diff --git a/src/plugins/collision/mod.rs b/src/plugins/collision/mod.rs
index c99eb6e2..7d3c18a8 100644
--- a/src/plugins/collision/mod.rs
+++ b/src/plugins/collision/mod.rs
@@ -10,7 +10,11 @@
 //!
 //! You can also find several utility methods for computing contacts in [`contact_query`].
 
+mod collider;
+pub use collider::*;
+
 pub mod broad_phase;
+pub mod collider_backend;
 pub mod contact_query;
 pub mod contact_reporting;
 pub mod narrow_phase;
diff --git a/src/plugins/collision/narrow_phase.rs b/src/plugins/collision/narrow_phase.rs
index 2bb64c72..4c5879db 100644
--- a/src/plugins/collision/narrow_phase.rs
+++ b/src/plugins/collision/narrow_phase.rs
@@ -2,6 +2,8 @@
 //!
 //! See [`NarrowPhasePlugin`].
 
+use std::marker::PhantomData;
+
 use crate::prelude::*;
 use bevy::ecs::query::Has;
 #[cfg(feature = "parallel")]
@@ -13,46 +15,96 @@ use bevy::tasks::{ComputeTaskPool, ParallelSlice};
 /// which is handled by the [`BroadPhasePlugin`].
 ///
 /// The results of the narrow phase are added into [`Collisions`].
-pub struct NarrowPhasePlugin;
+///
+/// The plugin takes a collider type. This should be [`Collider`] for
+/// the vast majority of applications, but for custom collisión backends
+/// you may use any collider that implements the [`AnyCollider`] trait.
+pub struct NarrowPhasePlugin<C: AnyCollider> {
+    _phantom: PhantomData<C>,
+}
 
-impl Plugin for NarrowPhasePlugin {
+impl<C: AnyCollider> Default for NarrowPhasePlugin<C> {
+    fn default() -> Self {
+        Self {
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<C: AnyCollider> Plugin for NarrowPhasePlugin<C> {
     fn build(&self, app: &mut App) {
-        app.init_resource::<NarrowPhaseConfig>()
+        // For some systems, we only want one instance, even if there are multiple
+        // NarrowPhasePlugin instances with different collider types.
+        let is_first_instance = app.world.is_resource_added::<NarrowPhaseInitialized>();
+
+        app.init_resource::<NarrowPhaseInitialized>()
+            .init_resource::<NarrowPhaseConfig>()
             .init_resource::<Collisions>()
             .register_type::<NarrowPhaseConfig>();
 
-        // Manage collision states like `during_current_frame` and remove old contacts
-        // TODO: It would be nice not to have collision state logic in the narrow phase
-        app.get_schedule_mut(PhysicsSchedule)
-            .expect("add PhysicsSchedule first")
-            .add_systems(
+        app.configure_sets(
+            SubstepSchedule,
+            (
+                NarrowPhaseSet::First,
+                NarrowPhaseSet::CollectCollisions,
+                NarrowPhaseSet::Last,
+            )
+                .chain()
+                .in_set(SubstepSet::NarrowPhase),
+        );
+
+        let physics_schedule = app
+            .get_schedule_mut(PhysicsSchedule)
+            .expect("add PhysicsSchedule first");
+
+        // Manage collision states like `during_current_frame` and remove old contacts.
+        // Only one narrow phase instance should do this.
+        // TODO: It would be nice not to have collision state logic in the narrow phase.
+        if !is_first_instance {
+            physics_schedule.add_systems(
                 (
-                    // Reset collision states before the substepping loop
+                    // Reset collision states before the substepping loop.
                     reset_collision_states
                         .after(PhysicsStepSet::BroadPhase)
                         .before(PhysicsStepSet::Substeps),
                     // Remove ended collisions after contact reporting
-                    ((|mut collisions: ResMut<Collisions>| {
-                        collisions.retain(|contacts| contacts.during_current_frame)
-                    }),)
-                        .chain()
+                    remove_ended_collisions
                         .after(PhysicsStepSet::ReportContacts)
                         .before(PhysicsStepSet::Sleeping),
                 )
                     .chain(),
             );
+        }
 
-        // Reset substep collision states and collect contacts into `Collisions`
-        app.get_schedule_mut(SubstepSchedule)
-            .expect("add SubstepSchedule first")
-            .add_systems(
-                (reset_substep_collision_states, collect_collisions)
-                    .chain()
-                    .in_set(SubstepSet::NarrowPhase),
+        let substep_schedule = app
+            .get_schedule_mut(SubstepSchedule)
+            .expect("add SubstepSchedule first");
+
+        // Reset substep collision states. Only one narrow phase instance should do this.
+        if !is_first_instance {
+            substep_schedule.add_systems(
+                reset_substep_collision_states
+                    .after(NarrowPhaseSet::First)
+                    .before(NarrowPhaseSet::CollectCollisions),
             );
+        }
+
+        // Collect contacts into `Collisions`.
+        substep_schedule.add_systems(
+            (
+                // Allowing ambiguities is required so that it's possible
+                // to have multiple collision backends at the same time.
+                collect_collisions::<C>.ambiguous_with_all(),
+            )
+                .chain()
+                .in_set(NarrowPhaseSet::CollectCollisions),
+        );
     }
 }
 
+#[derive(Resource, Default)]
+struct NarrowPhaseInitialized;
+
 /// A resource for configuring the [narrow phase](NarrowPhasePlugin).
 #[derive(Resource, Reflect, Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
@@ -77,24 +129,39 @@ impl Default for NarrowPhaseConfig {
     }
 }
 
+/// System sets for systems running in [`SubstepSet::NarrowPhase`].
+#[derive(SystemSet, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum NarrowPhaseSet {
+    /// Runs at the start of the narrow phase. Empty by default.
+    First,
+    /// Computes contacts between entities and adds them to the [`Collisions`] resource.
+    CollectCollisions,
+    /// Runs at the end of the narrow phase. Empty by default.
+    Last,
+}
+
 /// Computes contacts based on [`BroadCollisionPairs`] and adds them to [`Collisions`].
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::type_complexity)]
-pub fn collect_collisions(
-    bodies: Query<(
+pub fn collect_collisions<C: AnyCollider>(
+    query: Query<(
         Ref<Position>,
         Option<&AccumulatedTranslation>,
         Ref<Rotation>,
-        &Collider,
+        &C,
     )>,
     broad_collision_pairs: Res<BroadCollisionPairs>,
     mut collisions: ResMut<Collisions>,
     narrow_phase_config: Res<NarrowPhaseConfig>,
 ) {
+    if query.is_empty() {
+        return;
+    }
+
     // We want to preserve collisions between entities that are stationary
     // but not included in [`BroadCollisionPairs`].
     let stationary_collisions = collisions.0.keys().filter(|&&(e1, e2)| {
-        if let Ok([bundle1, bundle2]) = bodies.get_many([e1, e2]) {
+        if let Ok([bundle1, bundle2]) = query.get_many([e1, e2]) {
             let (position1, _, rotation1, _) = bundle1;
             let (position2, _, rotation2, _) = bundle2;
             !(position1.is_changed()
@@ -121,7 +188,7 @@ pub fn collect_collisions(
                     process_collision_pair(
                         *entity1,
                         *entity2,
-                        &bodies,
+                        &query,
                         &collisions,
                         &narrow_phase_config,
                         |contacts| {
@@ -143,7 +210,7 @@ pub fn collect_collisions(
             process_collision_pair(
                 entity1,
                 entity2,
-                &bodies,
+                &query,
                 &collisions,
                 &narrow_phase_config,
                 |contacts| {
@@ -158,14 +225,14 @@ pub fn collect_collisions(
 
 /// Helper method that calculates the intersection between two colliders to determine if they are in contact.
 #[allow(clippy::type_complexity)]
-fn process_collision_pair<F>(
+fn process_collision_pair<C: AnyCollider, F>(
     entity1: Entity,
     entity2: Entity,
     bodies: &Query<(
         Ref<Position>,
         Option<&AccumulatedTranslation>,
         Ref<Rotation>,
-        &Collider,
+        &C,
     )>,
     collisions: &ResMut<Collisions>,
     narrow_phase_config: &Res<NarrowPhaseConfig>,
@@ -188,11 +255,10 @@ fn process_collision_pair<F>(
             during_current_frame: true,
             during_current_substep: true,
             during_previous_frame: previous_contact.map_or(false, |c| c.during_previous_frame),
-            manifolds: contact_query::contact_manifolds(
-                collider1,
+            manifolds: collider1.contact_manifolds(
+                collider2,
                 position1,
                 *rotation1,
-                collider2,
                 position2,
                 *rotation2,
                 narrow_phase_config.prediction_distance,
@@ -207,6 +273,10 @@ fn process_collision_pair<F>(
     }
 }
 
+fn remove_ended_collisions(mut collisions: ResMut<Collisions>) {
+    collisions.retain(|contacts| contacts.during_current_frame);
+}
+
 // TODO: The collision state handling feels a bit confusing and error-prone.
 //       Ideally, the narrow phase wouldn't need to handle it at all, or it would at least be simpler.
 /// Resets collision states like `during_current_frame` and `during_previous_frame`.
diff --git a/src/plugins/mod.rs b/src/plugins/mod.rs
index b383c78d..d48323f7 100644
--- a/src/plugins/mod.rs
+++ b/src/plugins/mod.rs
@@ -33,7 +33,7 @@ pub mod sync;
 
 use bevy::utils::intern::Interned;
 pub use collision::{
-    broad_phase::BroadPhasePlugin, contact_reporting::ContactReportingPlugin,
+    broad_phase::BroadPhasePlugin, collider_backend::*, contact_reporting::ContactReportingPlugin,
     narrow_phase::NarrowPhasePlugin,
 };
 #[cfg(feature = "debug-plugin")]
@@ -57,11 +57,13 @@ use bevy::prelude::*;
 /// - [`PhysicsSetupPlugin`]: Sets up the physics engine by initializing the necessary schedules, sets and resources.
 /// - [`PreparePlugin`]: Runs systems at the start of each physics frame; initializes [rigid bodies](RigidBody)
 /// and [colliders](Collider) and updates components.
+/// - [`ColliderBackendPlugin`]: Handles generic collider backend logic, like initializing colliders and AABBs
+/// and updating related components.
 /// - [`BroadPhasePlugin`]: Collects pairs of potentially colliding entities into [`BroadCollisionPairs`] using
 /// [AABB](ColliderAabb) intersection checks.
-/// - [`IntegratorPlugin`]: Integrates Newton's 2nd law of motion, applying forces and moving entities according to their velocities.
 /// - [`NarrowPhasePlugin`]: Computes contacts between entities and sends collision events.
 /// - [`ContactReportingPlugin`]: Sends collision events and updates [`CollidingEntities`].
+/// - [`IntegratorPlugin`]: Integrates Newton's 2nd law of motion, applying forces and moving entities according to their velocities.
 /// - [`SolverPlugin`]: Solves positional and angular [constraints], updates velocities and solves velocity constraints
 /// (dynamic [friction](Friction) and [restitution](Restitution)).
 /// - [`SleepingPlugin`]: Controls when bodies should be deactivated and marked as [`Sleeping`] to improve performance.
@@ -189,10 +191,11 @@ impl PluginGroup for PhysicsPlugins {
         PluginGroupBuilder::start::<Self>()
             .add(PhysicsSetupPlugin::new(self.schedule))
             .add(PreparePlugin::new(self.schedule))
+            .add(ColliderBackendPlugin::<Collider>::new(self.schedule))
             .add(BroadPhasePlugin)
-            .add(IntegratorPlugin)
-            .add(NarrowPhasePlugin)
+            .add(NarrowPhasePlugin::<Collider>::default())
             .add(ContactReportingPlugin)
+            .add(IntegratorPlugin)
             .add(SolverPlugin)
             .add(SleepingPlugin)
             .add(SpatialQueryPlugin::new(self.schedule))
diff --git a/src/plugins/prepare.rs b/src/plugins/prepare.rs
index 91748e4f..d0a3b2a3 100644
--- a/src/plugins/prepare.rs
+++ b/src/plugins/prepare.rs
@@ -1,31 +1,28 @@
-//! Runs systems at the start of each physics frame; initializes [rigid bodies](RigidBody)
-//! and [colliders](Collider) and updates components.
+//! Runs systems at the start of each physics frame. Initializes [rigid bodies](RigidBody)
+//! and updates components.
 //!
 //! See [`PreparePlugin`].
 
 #![allow(clippy::type_complexity)]
 
 use crate::prelude::*;
-#[cfg(all(feature = "3d", feature = "async-collider"))]
-use bevy::scene::SceneInstance;
-use bevy::{
-    ecs::query::Has,
-    prelude::*,
-    utils::{intern::Interned, HashMap},
-};
+use bevy::{prelude::*, utils::intern::Interned};
 
-/// Runs systems at the start of each physics frame; initializes [rigid bodies](RigidBody)
-/// and [colliders](Collider) and updates components.
+/// Runs systems at the start of each physics frame. Initializes [rigid bodies](RigidBody)
+/// and updates components.
 ///
 /// - Adds missing rigid body components for entities with a [`RigidBody`] component
-/// - Adds missing collider components for entities with a [`Collider`] component
-/// - Adds missing mass properties for entities with a [`RigidBody`] or [`Collider`] component
-/// - Updates mass properties and adds [`ColliderMassProperties`] on top of the existing mass properties
+/// - Adds missing mass properties for entities with a [`RigidBody`] component
+/// - Updates mass properties
 /// - Clamps restitution coefficients between 0 and 1
 ///
 /// The [`Transform`] component will be initialized based on [`Position`] or [`Rotation`]
 /// and vice versa. You can configure this synchronization using the [`PrepareConfig`] resource.
 ///
+/// The plugin takes a collider type. This should be [`Collider`] for
+/// the vast majority of applications, but for custom collisión backends
+/// you may use any collider that implements the [`AnyCollider`] trait.
+///
 /// The systems run in [`PhysicsSet::Prepare`].
 pub struct PreparePlugin {
     schedule: Interned<dyn ScheduleLabel>,
@@ -98,77 +95,49 @@ impl Plugin for PreparePlugin {
                 .in_set(PhysicsSet::Prepare),
         );
 
-        app.init_resource::<ColliderStorageMap>()
-            .init_resource::<PrepareConfig>()
-            .register_type::<PrepareConfig>()
-            .add_systems(
-                self.schedule,
-                (
-                    apply_deferred,
-                    // Run transform propagation if new bodies or colliders have been added
-                    (
-                        bevy::transform::systems::sync_simple_transforms,
-                        bevy::transform::systems::propagate_transforms,
-                    )
-                        .chain()
-                        .run_if(any_new_physics_entities),
-                )
-                    .chain()
-                    .in_set(PrepareSet::PropagateTransforms),
-            )
-            .add_systems(
-                self.schedule,
-                init_rigid_bodies.in_set(PrepareSet::InitRigidBodies),
-            )
-            .add_systems(
-                self.schedule,
-                init_mass_properties.in_set(PrepareSet::InitMassProperties),
-            )
-            .add_systems(
-                self.schedule,
+        app.init_resource::<PrepareConfig>()
+            .register_type::<PrepareConfig>();
+
+        // Note: Collider logic is handled by the `ColliderBackendPlugin`
+        app.add_systems(
+            self.schedule,
+            (
+                apply_deferred,
+                // Run transform propagation if new bodies have been added
                 (
-                    init_colliders,
-                    apply_deferred,
-                    update_collider_parents,
-                    apply_deferred,
+                    bevy::transform::systems::sync_simple_transforms,
+                    bevy::transform::systems::propagate_transforms,
                 )
                     .chain()
-                    .in_set(PrepareSet::InitColliders),
-            )
-            .add_systems(
-                self.schedule,
-                init_transforms.in_set(PrepareSet::InitTransforms),
+                    .run_if(any_new::<RigidBody>),
             )
-            .add_systems(
-                self.schedule,
-                (
-                    (
-                        sync::propagate_collider_transforms,
-                        sync::update_child_collider_position,
-                    )
-                        .chain()
-                        .run_if(any_new_physics_entities),
-                    update_mass_properties,
-                    clamp_collider_density,
-                    clamp_restitution,
-                    // All the components we added above must exist before we can simulate the bodies.
-                    apply_deferred,
-                )
-                    .chain()
-                    .in_set(PrepareSet::Finalize),
-            );
-
-        app.add_systems(
-            PhysicsSchedule,
+                .chain()
+                .in_set(PrepareSet::PropagateTransforms),
+        )
+        .add_systems(
+            self.schedule,
+            init_rigid_bodies.in_set(PrepareSet::InitRigidBodies),
+        )
+        .add_systems(
+            self.schedule,
+            init_mass_properties.in_set(PrepareSet::InitMassProperties),
+        )
+        .add_systems(
+            self.schedule,
+            init_transforms::<RigidBody>.in_set(PrepareSet::InitTransforms),
+        )
+        .add_systems(
+            self.schedule,
             (
-                update_collider_storage.before(PhysicsStepSet::BroadPhase),
-                handle_collider_storage_removals.after(PhysicsStepSet::SpatialQuery),
-                handle_rigid_body_removals.after(PhysicsStepSet::SpatialQuery),
-            ),
+                update_mass_properties,
+                clamp_collider_density,
+                clamp_restitution,
+                // All the components we added above must exist before we can simulate the bodies.
+                apply_deferred,
+            )
+                .chain()
+                .in_set(PrepareSet::Finalize),
         );
-
-        #[cfg(all(feature = "3d", feature = "async-collider"))]
-        app.add_systems(Update, (init_async_colliders, init_async_scene_colliders));
     }
 }
 
@@ -193,34 +162,15 @@ impl Default for PrepareConfig {
     }
 }
 
-#[derive(Reflect, Clone, Copy, Component, Debug, Default, Deref, DerefMut, PartialEq)]
-#[reflect(Component)]
-pub(crate) struct PreviousColliderTransform(ColliderTransform);
-
-// Todo: Does this make sense in this file? It would also be nice to find an alternative approach.
-/// A hash map that stores some collider data that is needed when colliders are removed from
-/// rigid bodies.
-///
-/// This includes the collider parent for finding the associated rigid body after collider removal,
-/// and collider mass properties for updating the rigid body's mass properties when its collider is removed.
-///
-/// Ideally, we would just have some entity removal event or callback, but that doesn't
-/// exist yet, and `RemovedComponents` only returns entities, not component data.
-#[derive(Resource, Reflect, Clone, Debug, Default, Deref, DerefMut, PartialEq)]
-#[reflect(Resource)]
-pub(crate) struct ColliderStorageMap(
-    HashMap<Entity, (ColliderParent, ColliderMassProperties, ColliderTransform)>,
-);
-
-/// A run condition that returns `true` if new [rigid bodies](RigidBody) or [colliders](Collider)
-/// have been added. Used for avoiding unnecessary transform propagation.
-fn any_new_physics_entities(query: Query<(), Or<(Added<RigidBody>, Added<Collider>)>>) -> bool {
+/// A run condition that returns `true` if a component of the given type `C` has been added to any entity.
+pub fn any_new<C: Component>(query: Query<(), Added<C>>) -> bool {
     !query.is_empty()
 }
 
 // TODO: This system feels very overengineered. Try to clean it up?
-/// Initializes [`Transform`] based on [`Position`] and [`Rotation`] or vice versa.
-fn init_transforms(
+/// Initializes [`Transform`] based on [`Position`] and [`Rotation`] or vice versa
+/// when a component of the given type is inserted.
+pub fn init_transforms<C: Component>(
     mut commands: Commands,
     config: Res<PrepareConfig>,
     mut query: Query<
@@ -233,9 +183,9 @@ fn init_transforms(
             Option<&Rotation>,
             Option<&PreviousRotation>,
             Option<&Parent>,
-            Has<RigidBody>,
+            Has<C>,
         ),
-        Or<(Added<RigidBody>, Added<Collider>)>,
+        Added<C>,
     >,
     parents: Query<
         (
@@ -489,317 +439,32 @@ fn init_mass_properties(
     }
 }
 
-/// Initializes missing components for [colliders](Collider).
-fn init_colliders(
-    mut commands: Commands,
-    mut colliders: Query<
-        (
-            Entity,
-            &Collider,
-            Option<&ColliderAabb>,
-            Option<&ColliderDensity>,
-            Option<&ColliderMassProperties>,
-        ),
-        Added<Collider>,
-    >,
-) {
-    for (entity, collider, aabb, density, mass_properties) in &mut colliders {
-        let density = *density.unwrap_or(&ColliderDensity::default());
-        commands.entity(entity).insert((
-            *aabb.unwrap_or(&ColliderAabb::from_shape(collider.shape_scaled())),
-            density,
-            *mass_properties.unwrap_or(&collider.mass_properties(density.0)),
-            CollidingEntities::default(),
-        ));
-    }
-}
-
-/// Creates [`Collider`]s from [`AsyncCollider`]s if the meshes have become available.
-#[cfg(all(feature = "3d", feature = "async-collider"))]
-pub fn init_async_colliders(
-    mut commands: Commands,
-    meshes: Res<Assets<Mesh>>,
-    async_colliders: Query<(Entity, &Handle<Mesh>, &AsyncCollider)>,
-) {
-    for (entity, mesh_handle, async_collider) in async_colliders.iter() {
-        if let Some(mesh) = meshes.get(mesh_handle) {
-            let collider = match &async_collider.0 {
-                ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
-                ComputedCollider::TriMeshWithFlags(flags) => {
-                    Collider::trimesh_from_mesh_with_config(mesh, *flags)
-                }
-                ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
-                ComputedCollider::ConvexDecomposition(params) => {
-                    Collider::convex_decomposition_from_mesh_with_config(mesh, params)
-                }
-            };
-            if let Some(collider) = collider {
-                commands
-                    .entity(entity)
-                    .insert(collider)
-                    .remove::<AsyncCollider>();
-            } else {
-                error!("Unable to generate collider from mesh {:?}", mesh);
-            }
-        }
-    }
-}
-
-/// Creates [`Collider`]s from [`AsyncSceneCollider`]s if the scenes have become available.
-#[cfg(all(feature = "3d", feature = "async-collider"))]
-pub fn init_async_scene_colliders(
-    mut commands: Commands,
-    meshes: Res<Assets<Mesh>>,
-    scene_spawner: Res<SceneSpawner>,
-    async_colliders: Query<(Entity, &SceneInstance, &AsyncSceneCollider)>,
-    children: Query<&Children>,
-    mesh_handles: Query<(&Name, &Handle<Mesh>)>,
-) {
-    for (scene_entity, scene_instance, async_scene_collider) in async_colliders.iter() {
-        if scene_spawner.instance_is_ready(**scene_instance) {
-            for child_entity in children.iter_descendants(scene_entity) {
-                if let Ok((name, handle)) = mesh_handles.get(child_entity) {
-                    let Some(collider_data) = async_scene_collider
-                        .meshes_by_name
-                        .get(name.as_str())
-                        .cloned()
-                        .unwrap_or(
-                            async_scene_collider
-                                .default_shape
-                                .clone()
-                                .map(|shape| AsyncSceneColliderData { shape, ..default() }),
-                        )
-                    else {
-                        continue;
-                    };
-
-                    let mesh = meshes.get(handle).expect("mesh should already be loaded");
-
-                    let collider = match collider_data.shape {
-                        ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
-                        ComputedCollider::TriMeshWithFlags(flags) => {
-                            Collider::trimesh_from_mesh_with_config(mesh, flags)
-                        }
-                        ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
-                        ComputedCollider::ConvexDecomposition(params) => {
-                            Collider::convex_decomposition_from_mesh_with_config(mesh, &params)
-                        }
-                    };
-                    if let Some(collider) = collider {
-                        commands.entity(child_entity).insert((
-                            collider,
-                            collider_data.layers,
-                            ColliderDensity(collider_data.density),
-                        ));
-                    } else {
-                        error!(
-                            "unable to generate collider from mesh {:?} with name {}",
-                            mesh, name
-                        );
-                    }
-                }
-            }
-
-            commands.entity(scene_entity).remove::<AsyncSceneCollider>();
-        }
-    }
-}
-
-fn update_collider_parents(
-    mut commands: Commands,
-    mut bodies: Query<(Entity, Option<&mut ColliderParent>, Has<Collider>), With<RigidBody>>,
-    children: Query<&Children>,
-    mut child_colliders: Query<Option<&mut ColliderParent>, (With<Collider>, Without<RigidBody>)>,
-) {
-    for (entity, collider_parent, has_collider) in &mut bodies {
-        if has_collider {
-            if let Some(mut collider_parent) = collider_parent {
-                collider_parent.0 = entity;
-            } else {
-                commands.entity(entity).insert((
-                    ColliderParent(entity),
-                    // Todo: This probably causes a one frame delay. Compute real value?
-                    ColliderTransform::default(),
-                    PreviousColliderTransform::default(),
-                ));
-            }
-        }
-        for child in children.iter_descendants(entity) {
-            if let Ok(collider_parent) = child_colliders.get_mut(child) {
-                if let Some(mut collider_parent) = collider_parent {
-                    collider_parent.0 = entity;
-                } else {
-                    commands.entity(child).insert((
-                        ColliderParent(entity),
-                        // Todo: This probably causes a one frame delay. Compute real value?
-                        ColliderTransform::default(),
-                        PreviousColliderTransform::default(),
-                    ));
-                }
-            }
-        }
-    }
-}
-
-/// Updates colliders when the rigid bodies they were attached to have been removed.
-fn handle_rigid_body_removals(
-    mut commands: Commands,
-    colliders: Query<(Entity, &ColliderParent), Without<RigidBody>>,
-    bodies: Query<(), With<RigidBody>>,
-    removals: RemovedComponents<RigidBody>,
-) {
-    // Return if no rigid bodies have been removed
-    if removals.is_empty() {
-        return;
-    }
-
-    for (collider_entity, collider_parent) in &colliders {
-        // If the body associated with the collider parent entity doesn't exist,
-        // remove ColliderParent and ColliderTransform.
-        if !bodies.contains(collider_parent.get()) {
-            commands.entity(collider_entity).remove::<(
-                ColliderParent,
-                ColliderTransform,
-                PreviousColliderTransform,
-            )>();
-        }
-    }
-}
-
-/// Updates [`ColliderStorageMap`], a resource that stores some collider properties that need
-/// to be handled when colliders are removed from entities.
-fn update_collider_storage(
-    // TODO: Maybe it's enough to store only colliders that aren't on rigid body entities
-    //       directly (i.e. child colliders)
-    colliders: Query<
+/// Updates each body's [`InverseMass`] and [`InverseInertia`] whenever [`Mass`] or [`Inertia`] are changed.
+pub fn update_mass_properties(
+    mut bodies: Query<
         (
             Entity,
-            &ColliderParent,
-            &ColliderMassProperties,
-            &ColliderTransform,
-        ),
-        (
-            With<Collider>,
-            Or<(
-                Changed<ColliderParent>,
-                Changed<ColliderTransform>,
-                Changed<ColliderMassProperties>,
-            )>,
-        ),
-    >,
-    mut storage: ResMut<ColliderStorageMap>,
-) {
-    for (entity, parent, collider_mass_properties, collider_transform) in &colliders {
-        storage.insert(
-            entity,
-            (*parent, *collider_mass_properties, *collider_transform),
-        );
-    }
-}
-
-/// Removes removed colliders from the [`ColliderStorageMap`] resource at the end of the physics frame.
-fn handle_collider_storage_removals(
-    mut removals: RemovedComponents<Collider>,
-    mut storage: ResMut<ColliderStorageMap>,
-) {
-    removals.read().for_each(|entity| {
-        storage.remove(&entity);
-    });
-}
-
-/// Updates each body's mass properties whenever their dependant mass properties or the body's [`Collider`] change.
-///
-/// Also updates the collider's mass properties if the body has a collider.
-fn update_mass_properties(
-    mut bodies: Query<(Entity, &RigidBody, MassPropertiesQuery)>,
-    mut colliders: Query<
-        (
-            &ColliderTransform,
-            &mut PreviousColliderTransform,
-            &ColliderParent,
-            Ref<Collider>,
-            &ColliderDensity,
-            &mut ColliderMassProperties,
+            &RigidBody,
+            Ref<Mass>,
+            &mut InverseMass,
+            Ref<Inertia>,
+            &mut InverseInertia,
         ),
-        Or<(
-            Changed<Collider>,
-            Changed<ColliderTransform>,
-            Changed<ColliderDensity>,
-            Changed<ColliderMassProperties>,
-        )>,
+        Or<(Changed<Mass>, Changed<Inertia>)>,
     >,
-    collider_map: Res<ColliderStorageMap>,
-    mut removed_colliders: RemovedComponents<Collider>,
 ) {
-    for (
-        collider_transform,
-        mut previous_collider_transform,
-        collider_parent,
-        collider,
-        density,
-        mut collider_mass_properties,
-    ) in &mut colliders
-    {
-        if let Ok((_, _, mut mass_properties)) = bodies.get_mut(collider_parent.0) {
-            // Subtract previous collider mass props from the body's own mass props,
-            // If the collider is new, it doesn't have previous mass props, so we shouldn't subtract anything.
-            if !collider.is_added() {
-                mass_properties -= ColliderMassProperties {
-                    center_of_mass: CenterOfMass(
-                        previous_collider_transform
-                            .transform_point(collider_mass_properties.center_of_mass.0),
-                    ),
-                    ..*collider_mass_properties
-                };
-            }
-
-            previous_collider_transform.0 = *collider_transform;
-
-            // Update collider mass props
-            *collider_mass_properties = collider.mass_properties(density.max(Scalar::EPSILON));
-
-            // Add new collider mass props to the body's mass props
-            mass_properties += ColliderMassProperties {
-                center_of_mass: CenterOfMass(
-                    collider_transform.transform_point(collider_mass_properties.center_of_mass.0),
-                ),
-                ..*collider_mass_properties
-            };
-        }
-    }
-
-    // Subtract mass properties of removed colliders
-    for entity in removed_colliders.read() {
-        if let Some((collider_parent, collider_mass_properties, collider_transform)) =
-            collider_map.get(&entity)
-        {
-            if let Ok((_, _, mut mass_properties)) = bodies.get_mut(collider_parent.0) {
-                mass_properties -= ColliderMassProperties {
-                    center_of_mass: CenterOfMass(
-                        collider_transform
-                            .transform_point(collider_mass_properties.center_of_mass.0),
-                    ),
-                    ..*collider_mass_properties
-                };
-            }
-        }
-    }
-
-    for (entity, rb, mut mass_properties) in &mut bodies {
-        let is_mass_valid =
-            mass_properties.mass.is_finite() && mass_properties.mass.0 >= Scalar::EPSILON;
+    for (entity, rb, mass, mut inv_mass, inertia, mut inv_inertia) in &mut bodies {
+        let is_mass_valid = mass.is_finite() && mass.0 >= Scalar::EPSILON;
         #[cfg(feature = "2d")]
-        let is_inertia_valid =
-            mass_properties.inertia.is_finite() && mass_properties.inertia.0 >= Scalar::EPSILON;
+        let is_inertia_valid = inertia.is_finite() && inertia.0 >= Scalar::EPSILON;
         #[cfg(feature = "3d")]
-        let is_inertia_valid =
-            mass_properties.inertia.is_finite() && *mass_properties.inertia != Inertia::ZERO;
+        let is_inertia_valid = inertia.is_finite() && *inertia != Inertia::ZERO;
 
-        if mass_properties.mass.is_changed() && is_mass_valid {
-            mass_properties.inverse_mass.0 = 1.0 / mass_properties.mass.0;
+        if mass.is_changed() && is_mass_valid {
+            inv_mass.0 = 1.0 / mass.0;
         }
-        if mass_properties.inertia.is_changed() && is_inertia_valid {
-            mass_properties.inverse_inertia.0 = mass_properties.inertia.inverse().0;
+        if inertia.is_changed() && is_inertia_valid {
+            inv_inertia.0 = inertia.inverse().0;
         }
 
         // Warn about dynamic bodies with no mass or inertia
diff --git a/src/plugins/sleeping.rs b/src/plugins/sleeping.rs
index 35d41338..661c4c1a 100644
--- a/src/plugins/sleeping.rs
+++ b/src/plugins/sleeping.rs
@@ -27,7 +27,6 @@ impl Plugin for SleepingPlugin {
                 (
                     mark_sleeping_bodies,
                     wake_on_changed,
-                    wake_on_collider_removed,
                     wake_all_sleeping_bodies.run_if(resource_changed::<Gravity>()),
                 )
                     .chain()
@@ -46,7 +45,7 @@ type SleepingQueryComponents = (
 
 /// Adds the [`Sleeping`] component to bodies whose linear and anigular velocities have been
 /// under the [`SleepingThreshold`] for a duration indicated by [`DeactivationTime`].
-fn mark_sleeping_bodies(
+pub fn mark_sleeping_bodies(
     mut commands: Commands,
     mut bodies: Query<SleepingQueryComponents, (Without<Sleeping>, Without<SleepingDisabled>)>,
     deactivation_time: Res<DeactivationTime>,
@@ -102,7 +101,7 @@ type WokeUpFilter = Or<(
 /// Removes the [`Sleeping`] component from sleeping bodies when properties like
 /// position, rotation, velocity and external forces are changed.
 #[allow(clippy::type_complexity)]
-fn wake_on_changed(
+pub fn wake_on_changed(
     mut commands: Commands,
     mut bodies: Query<(Entity, &mut TimeSleeping), (With<Sleeping>, WokeUpFilter)>,
 ) {
@@ -112,38 +111,6 @@ fn wake_on_changed(
     }
 }
 
-type ColliderTransformedFilter = Or<(
-    Changed<Collider>,
-    Changed<Transform>,
-    Changed<ColliderTransform>,
-)>;
-
-/// Removes the [`Sleeping`] component from sleeping bodies when any of their
-/// colliders have been removed.
-#[allow(clippy::type_complexity)]
-fn wake_on_collider_removed(
-    mut commands: Commands,
-    mut bodies: Query<(Entity, &mut TimeSleeping), With<RigidBody>>,
-    all_colliders: Query<&ColliderParent>,
-    child_colliders: Query<&ColliderParent, (Without<RigidBody>, ColliderTransformedFilter)>,
-    mut removed_colliders: RemovedComponents<Collider>,
-    // This stores some collider data so that we can access it even though the entity has been removed
-    collider_storage: Res<ColliderStorageMap>,
-) {
-    let removed_colliders_iter =
-        all_colliders.iter_many(removed_colliders.read().filter_map(|entity| {
-            collider_storage
-                .get(&entity)
-                .map(|(rb_entity, _, _)| rb_entity.get())
-        }));
-    for collider_parent in child_colliders.iter().chain(removed_colliders_iter) {
-        if let Ok((entity, mut time_sleeping)) = bodies.get_mut(collider_parent.get()) {
-            commands.entity(entity).remove::<Sleeping>();
-            time_sleeping.0 = 0.0;
-        }
-    }
-}
-
 /// Removes the [`Sleeping`] component from all sleeping bodies.
 /// Triggered automatically when [`Gravity`] is changed.
 fn wake_all_sleeping_bodies(
diff --git a/src/plugins/spatial_query/mod.rs b/src/plugins/spatial_query/mod.rs
index 184a37f1..cdfd40b2 100644
--- a/src/plugins/spatial_query/mod.rs
+++ b/src/plugins/spatial_query/mod.rs
@@ -158,7 +158,7 @@ pub use ray_caster::*;
 pub use shape_caster::*;
 pub use system_param::*;
 
-use crate::prelude::*;
+use crate::{prelude::*, prepare::PrepareSet};
 use bevy::{prelude::*, utils::intern::Interned};
 
 /// Initializes the [`SpatialQueryPipeline`] resource and handles component-based [spatial queries](spatial_query)
diff --git a/src/plugins/sync.rs b/src/plugins/sync.rs
index 4d71ea1a..06abfa23 100644
--- a/src/plugins/sync.rs
+++ b/src/plugins/sync.rs
@@ -4,7 +4,7 @@
 //! See [`SyncPlugin`].
 
 use crate::{prelude::*, utils::get_pos_translation};
-use bevy::{ecs::query::Has, prelude::*, utils::intern::Interned};
+use bevy::{prelude::*, utils::intern::Interned};
 
 /// Responsible for synchronizing physics components with other data, like keeping [`Position`]
 /// and [`Rotation`] in sync with `Transform`.
@@ -52,11 +52,24 @@ impl Plugin for SyncPlugin {
         app.init_resource::<SyncConfig>()
             .register_type::<SyncConfig>();
 
+        app.configure_sets(
+            self.schedule,
+            (
+                SyncSet::First,
+                SyncSet::TransformToPosition,
+                SyncSet::PositionToTransform,
+                SyncSet::Update,
+                SyncSet::Last,
+            )
+                .chain()
+                .in_set(PhysicsSet::Sync),
+        );
+
         // Initialize `PreviousGlobalTransform` and apply `Transform` changes that happened
         // between the end of the previous physics frame and the start of this physics frame.
         app.add_systems(
             self.schedule,
-            ((
+            (
                 bevy::transform::systems::sync_simple_transforms,
                 bevy::transform::systems::propagate_transforms,
                 init_previous_global_transform,
@@ -66,52 +79,42 @@ impl Plugin for SyncPlugin {
             )
                 .chain()
                 .after(PhysicsSet::Prepare)
-                .before(PhysicsSet::StepSimulation),)
-                .chain()
+                .before(PhysicsSet::StepSimulation)
                 .run_if(|config: Res<SyncConfig>| config.transform_to_position),
         );
 
-        // Apply `Transform`, `Position` and `Rotation` changes that happened during the physics frame.
+        // Apply `Transform` changes to `Position` and `Rotation`
         app.add_systems(
             self.schedule,
             (
-                (
-                    // Apply `Transform` changes to `Position` and `Rotation`
-                    bevy::transform::systems::sync_simple_transforms,
-                    bevy::transform::systems::propagate_transforms,
-                    transform_to_position,
-                )
-                    .chain()
-                    .run_if(|config: Res<SyncConfig>| config.transform_to_position),
-                // Apply `Position` and `Rotation` changes to `Transform`
-                position_to_transform
-                    .run_if(|config: Res<SyncConfig>| config.position_to_transform),
-                (
-                    // Update `PreviousGlobalTransform` for next frame's `GlobalTransform` change detection
-                    bevy::transform::systems::sync_simple_transforms,
-                    bevy::transform::systems::propagate_transforms,
-                    update_previous_global_transforms,
-                )
-                    .chain()
-                    .run_if(|config: Res<SyncConfig>| config.transform_to_position),
-                update_collider_scale,
+                bevy::transform::systems::sync_simple_transforms,
+                bevy::transform::systems::propagate_transforms,
+                transform_to_position,
             )
                 .chain()
-                .in_set(PhysicsSet::Sync),
+                .in_set(SyncSet::TransformToPosition)
+                .run_if(|config: Res<SyncConfig>| config.transform_to_position),
         );
 
-        // Update child colliders before narrow phase in substepping loop
-        let substep_schedule = app
-            .get_schedule_mut(SubstepSchedule)
-            .expect("add SubstepSchedule first");
-        substep_schedule.add_systems(
+        // Apply `Position` and `Rotation` changes to `Transform`
+        app.add_systems(
+            self.schedule,
+            position_to_transform
+                .in_set(SyncSet::PositionToTransform)
+                .run_if(|config: Res<SyncConfig>| config.position_to_transform),
+        );
+
+        // Update `PreviousGlobalTransform` for next frame's `GlobalTransform` change detection
+        app.add_systems(
+            self.schedule,
             (
-                propagate_collider_transforms,
-                update_child_collider_position,
+                bevy::transform::systems::sync_simple_transforms,
+                bevy::transform::systems::propagate_transforms,
+                update_previous_global_transforms,
             )
                 .chain()
-                .after(SubstepSet::Integrate)
-                .before(SubstepSet::NarrowPhase),
+                .in_set(SyncSet::Update)
+                .run_if(|config: Res<SyncConfig>| config.transform_to_position),
         );
     }
 }
@@ -136,17 +139,31 @@ impl Default for SyncConfig {
     }
 }
 
+/// System sets for systems running in [`PhysiCsSet::Sync`].
+#[derive(SystemSet, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum SyncSet {
+    /// Runs at the start of [`PhysicsSet::Sync`]. Empty by default.
+    First,
+    /// Updates [`Position`] and [`Rotation`] based on transform changes.
+    TransformToPosition,
+    /// Updates transforms based on [`Position`] and [`Rotation`] changes.
+    PositionToTransform,
+    /// Handles transform propagation and other updates after physics positions have been synced with transforms.
+    Update,
+    /// Runs at the end of [`PhysicsSet::Sync`]. Empty by default.
+    Last,
+}
+
 /// The global transform of a body at the end of the previous frame.
 /// Used for detecting if the transform was modified before the start of the physics schedule.
 #[derive(Component, Reflect, Clone, Copy, Debug, Default, Deref, DerefMut, PartialEq)]
 #[reflect(Component)]
 pub struct PreviousGlobalTransform(pub GlobalTransform);
 
-type PhysicsObjectAddedFilter = Or<(Added<RigidBody>, Added<Collider>)>;
-
-fn init_previous_global_transform(
+#[allow(clippy::type_complexity)]
+pub(crate) fn init_previous_global_transform(
     mut commands: Commands,
-    query: Query<(Entity, &GlobalTransform), PhysicsObjectAddedFilter>,
+    query: Query<(Entity, &GlobalTransform), Or<(Added<Position>, Added<Rotation>)>>,
 ) {
     for (entity, transform) in &query {
         commands
@@ -155,255 +172,12 @@ fn init_previous_global_transform(
     }
 }
 
-#[allow(clippy::type_complexity)]
-pub(crate) fn update_child_collider_position(
-    mut colliders: Query<
-        (
-            &ColliderTransform,
-            &mut Position,
-            &mut Rotation,
-            &ColliderParent,
-        ),
-        Without<RigidBody>,
-    >,
-    parents: Query<(&Position, &Rotation), (With<RigidBody>, With<Children>)>,
-) {
-    for (collider_transform, mut position, mut rotation, parent) in &mut colliders {
-        let Ok((parent_pos, parent_rot)) = parents.get(parent.get()) else {
-            continue;
-        };
-
-        position.0 = parent_pos.0 + parent_rot.rotate(collider_transform.translation);
-        #[cfg(feature = "2d")]
-        {
-            *rotation = *parent_rot + collider_transform.rotation;
-        }
-        #[cfg(feature = "3d")]
-        {
-            *rotation = (parent_rot.0 * collider_transform.rotation.0)
-                .normalize()
-                .into();
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub(crate) fn update_collider_scale(
-    mut colliders: ParamSet<(
-        // Root bodies
-        Query<(&Transform, &mut Collider), Without<Parent>>,
-        // Child colliders
-        Query<(&ColliderTransform, &mut Collider), With<Parent>>,
-    )>,
-) {
-    // Update collider scale for root bodies
-    for (transform, mut collider) in &mut colliders.p0() {
-        #[cfg(feature = "2d")]
-        let scale = transform.scale.truncate().adjust_precision();
-        #[cfg(feature = "3d")]
-        let scale = transform.scale.adjust_precision();
-        if scale != collider.scale() {
-            // TODO: Support configurable subdivision count for shapes that
-            //       can't be represented without approximations after scaling.
-            collider.set_scale(scale, 10);
-        }
-    }
-
-    // Update collider scale for child colliders
-    for (collider_transform, mut collider) in &mut colliders.p1() {
-        if collider_transform.scale != collider.scale() {
-            // TODO: Support configurable subdivision count for shapes that
-            //       can't be represented without approximations after scaling.
-            collider.set_scale(collider_transform.scale, 10);
-        }
-    }
-}
-
-/// Updates [`ColliderTransform`]s based on entity hierarchies. Each transform is computed by recursively
-/// traversing the children of each rigid body and adding their transforms together to form
-/// the total transform relative to the body.
-///
-/// This is largely a clone of `propagate_transforms` in `bevy_transform`.
-#[allow(clippy::type_complexity)]
-pub(crate) fn propagate_collider_transforms(
-    mut root_query: Query<(Entity, Ref<Transform>, &Children), Without<Parent>>,
-    collider_query: Query<
-        (
-            Ref<Transform>,
-            Option<&mut ColliderTransform>,
-            Option<&Children>,
-        ),
-        With<Parent>,
-    >,
-    parent_query: Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
-) {
-    root_query.par_iter_mut().for_each(
-        |(entity, transform,children)| {
-            for (child, child_transform, is_child_rb, parent) in parent_query.iter_many(children) {
-                assert_eq!(
-                    parent.get(), entity,
-                    "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
-                );
-                let child_transform = ColliderTransform::from(*child_transform);
-
-                // SAFETY:
-                // - `child` must have consistent parentage, or the above assertion would panic.
-                // Since `child` is parented to a root entity, the entire hierarchy leading to it is consistent.
-                // - We may operate as if all descendants are consistent, since `propagate_collider_transform_recursive` will panic before 
-                //   continuing to propagate if it encounters an entity with inconsistent parentage.
-                // - Since each root entity is unique and the hierarchy is consistent and forest-like,
-                //   other root entities' `propagate_collider_transform_recursive` calls will not conflict with this one.
-                // - Since this is the only place where `transform_query` gets used, there will be no conflicting fetches elsewhere.
-                unsafe {
-                    propagate_collider_transforms_recursive(
-                        if is_child_rb {
-                            ColliderTransform {
-                                scale: child_transform.scale,
-                                ..default()
-                            }
-                        } else {
-                            let transform = ColliderTransform::from(*transform);
-
-                            ColliderTransform {
-                                translation: transform.scale * child_transform.translation,
-                                rotation: child_transform.rotation,
-                                scale: (transform.scale * child_transform.scale).max(Vector::splat(Scalar::EPSILON)),
-                            }
-                        },
-                        &collider_query,
-                        &parent_query,
-                        child,
-                        transform.is_changed() || parent.is_changed()
-                    );
-                }
-            }
-        },
-    );
-}
-
-/// Recursively computes the [`ColliderTransform`] for `entity` and all of its descendants
-/// by propagating transforms.
-///
-/// This is largely a clone of `propagate_recursive` in `bevy_transform`.
-///
-/// # Panics
-///
-/// If `entity`'s descendants have a malformed hierarchy, this function will panic occur before propagating
-/// the transforms of any malformed entities and their descendants.
-///
-/// # Safety
-///
-/// - While this function is running, `transform_query` must not have any fetches for `entity`,
-/// nor any of its descendants.
-/// - The caller must ensure that the hierarchy leading to `entity`
-/// is well-formed and must remain as a tree or a forest. Each entity must have at most one parent.
-#[allow(clippy::type_complexity)]
-unsafe fn propagate_collider_transforms_recursive(
-    transform: ColliderTransform,
-    collider_query: &Query<
-        (
-            Ref<Transform>,
-            Option<&mut ColliderTransform>,
-            Option<&Children>,
-        ),
-        With<Parent>,
-    >,
-    parent_query: &Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
-    entity: Entity,
-    mut changed: bool,
-) {
-    let children = {
-        // SAFETY: This call cannot create aliased mutable references.
-        //   - The top level iteration parallelizes on the roots of the hierarchy.
-        //   - The caller ensures that each child has one and only one unique parent throughout the entire
-        //     hierarchy.
-        //
-        // For example, consider the following malformed hierarchy:
-        //
-        //     A
-        //   /   \
-        //  B     C
-        //   \   /
-        //     D
-        //
-        // D has two parents, B and C. If the propagation passes through C, but the Parent component on D points to B,
-        // the above check will panic as the origin parent does match the recorded parent.
-        //
-        // Also consider the following case, where A and B are roots:
-        //
-        //  A       B
-        //   \     /
-        //    C   D
-        //     \ /
-        //      E
-        //
-        // Even if these A and B start two separate tasks running in parallel, one of them will panic before attempting
-        // to mutably access E.
-        let Ok((transform_ref, collider_transform, children)) =
-            (unsafe { collider_query.get_unchecked(entity) })
-        else {
-            return;
-        };
-
-        changed |= transform_ref.is_changed();
-        if changed {
-            if let Some(mut collider_transform) = collider_transform {
-                if *collider_transform != transform {
-                    *collider_transform = transform;
-                }
-            }
-        }
-
-        children
-    };
-
-    let Some(children) = children else { return };
-    for (child, child_transform, is_rb, parent) in parent_query.iter_many(children) {
-        assert_eq!(
-            parent.get(), entity,
-            "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
-        );
-
-        let child_transform = ColliderTransform::from(*child_transform);
-
-        // SAFETY: The caller guarantees that `transform_query` will not be fetched
-        // for any descendants of `entity`, so it is safe to call `propagate_collider_transforms_recursive` for each child.
-        //
-        // The above assertion ensures that each child has one and only one unique parent throughout the
-        // entire hierarchy.
-        unsafe {
-            propagate_collider_transforms_recursive(
-                if is_rb {
-                    ColliderTransform {
-                        scale: child_transform.scale,
-                        ..default()
-                    }
-                } else {
-                    ColliderTransform {
-                        translation: transform.transform_point(child_transform.translation),
-                        #[cfg(feature = "2d")]
-                        rotation: transform.rotation + child_transform.rotation,
-                        #[cfg(feature = "3d")]
-                        rotation: Rotation(transform.rotation.0 * child_transform.rotation.0),
-                        scale: (transform.scale * child_transform.scale)
-                            .max(Vector::splat(Scalar::EPSILON)),
-                    }
-                },
-                collider_query,
-                parent_query,
-                child,
-                changed || parent.is_changed(),
-            );
-        }
-    }
-}
-
 /// Copies `GlobalTransform` changes to [`Position`] and [`Rotation`].
 /// This allows users to use transforms for moving and positioning bodies and colliders.
 ///
 /// To account for hierarchies, transform propagation should be run before this system.
 #[allow(clippy::type_complexity)]
-fn transform_to_position(
+pub fn transform_to_position(
     mut query: Query<(
         &GlobalTransform,
         &PreviousGlobalTransform,
@@ -494,7 +268,7 @@ type ParentComponents = (
 /// Nested rigid bodies move independently of each other, so the `Transform`s of child entities are updated
 /// based on their own and their parent's [`Position`] and [`Rotation`].
 #[cfg(feature = "2d")]
-fn position_to_transform(
+pub fn position_to_transform(
     mut query: Query<PosToTransformComponents, PosToTransformFilter>,
     parents: Query<ParentComponents, With<Children>>,
 ) {
@@ -541,7 +315,7 @@ fn position_to_transform(
 /// Nested rigid bodies move independently of each other, so the `Transform`s of child entities are updated
 /// based on their own and their parent's [`Position`] and [`Rotation`].
 #[cfg(feature = "3d")]
-fn position_to_transform(
+pub fn position_to_transform(
     mut query: Query<PosToTransformComponents, PosToTransformFilter>,
     parents: Query<ParentComponents, With<Children>>,
 ) {
@@ -576,7 +350,7 @@ fn position_to_transform(
 }
 
 /// Updates [`PreviousGlobalTransform`] by setting it to `GlobalTransform` at the very end or start of a frame.
-fn update_previous_global_transforms(
+pub fn update_previous_global_transforms(
     mut bodies: Query<(&GlobalTransform, &mut PreviousGlobalTransform)>,
 ) {
     for (transform, mut previous_transform) in &mut bodies {