fix(ccd): honor filter_contact_pair PhysicsHook during CCD

Closes #754.

The narrow phase already consulted the user's `filter_contact_pair`
hook when deciding whether to compute contacts for a pair. CCD's
`find_first_impact` and `predict_impacts_at_next_positions` did not,
so fast-moving CCD-enabled bodies still got motion-clamped by pairs
the user had filtered out.

This thread `hooks: &dyn PhysicsHooks` through both CCD entry points
and calls the filter at each pair-evaluation site (one in
`find_first_impact`, two in `predict_impacts_at_next_positions` —
the first-sweep loop and the resweep loop). The shared logic lives
in a private `pair_filtered_out_by_hooks` helper in `ccd_solver.rs`
that mirrors narrow-phase semantics exactly.

Signature change: `CCDSolver::find_first_impact` and
`CCDSolver::predict_impacts_at_next_positions` take an extra
`hooks: &dyn PhysicsHooks` argument. `PhysicsPipeline::step` callers
are unaffected; only code calling the CCD solver directly needs to
update.

Regression test added in `pipeline::physics_pipeline::test` that
reproduces the bug: a 200 m/s CCD body rejected from a pair via
`filter_contact_pair` passes through instead of clamping.

Author: nickyvanurk

CHANGELOG.md

@@ -1,3 +1,17 @@
+## Unreleased
+
+### Fixed
+
+- Continuous Collision Detection now consults the user's `PhysicsHooks::filter_contact_pair`
+  hook, matching narrow-phase semantics. Previously, CCD would clamp a fast-moving body's
+  motion at a predicted impact with a pair the user had filtered out. Closes #754.
+
+### Modified
+
+- **Breaking (CCD solver direct callers only):** `CCDSolver::find_first_impact` and
+  `CCDSolver::predict_impacts_at_next_positions` now take an extra `hooks: &dyn PhysicsHooks`
+  argument. `PhysicsPipeline::step` callers are unaffected.
+
 ## v0.31.0 (09 Jan. 2026)
 
 ### Modified

src/dynamics/ccd/ccd_solver.rs

@@ -1,14 +1,52 @@
 use super::TOIEntry;
 use crate::alloc_prelude::*;
 use crate::dynamics::{IntegrationParameters, IslandManager, RigidBodyHandle, RigidBodySet};
-use crate::geometry::{BroadPhaseBvh, ColliderParent, ColliderSet, CollisionEvent, NarrowPhase};
+use crate::geometry::{
+    BroadPhaseBvh, Collider, ColliderHandle, ColliderParent, ColliderSet, CollisionEvent,
+    NarrowPhase,
+};
 use crate::math::Real;
 use crate::parry::utils::SortedPair;
-use crate::pipeline::{EventHandler, QueryFilter};
+use crate::pipeline::{ActiveHooks, EventHandler, PairFilterContext, PhysicsHooks, QueryFilter};
 use crate::prelude::{ActiveEvents, CollisionEventFlags};
 use alloc::collections::BinaryHeap;
 use parry::utils::hashmap::HashMap;
 
+/// Returns `true` if the user's `filter_contact_pair` hook rejected this
+/// pair. Mirrors the narrow-phase filter call in `NarrowPhase::compute_contacts`
+/// so CCD respects the same user-level contact filtering (see issue #754).
+///
+/// Note: the narrow phase may invoke this hook for sensor pairs too (it
+/// uses `solver_flags` to decide downstream). The CCD sweep sites skip
+/// sensors before calling this helper, which is intentional — CCD only
+/// resolves contact TOIs, and sensor intersections are reported elsewhere.
+#[inline]
+fn pair_filtered_out_by_hooks(
+    hooks: &dyn PhysicsHooks,
+    bodies: &RigidBodySet,
+    colliders: &ColliderSet,
+    co1: &Collider,
+    co2: &Collider,
+    ch1: ColliderHandle,
+    ch2: ColliderHandle,
+    bh1: Option<RigidBodyHandle>,
+    bh2: Option<RigidBodyHandle>,
+) -> bool {
+    let active_hooks = co1.flags.active_hooks | co2.flags.active_hooks;
+    if !active_hooks.contains(ActiveHooks::FILTER_CONTACT_PAIRS) {
+        return false;
+    }
+    let context = PairFilterContext {
+        bodies,
+        colliders,
+        rigid_body1: bh1,
+        rigid_body2: bh2,
+        collider1: ch1,
+        collider2: ch2,
+    };
+    hooks.filter_contact_pair(&context).is_none()
+}
+
 pub enum PredictedImpacts {
     Impacts(HashMap<RigidBodyHandle, Real>),
     ImpactsAfterEndTime(Real),
@@ -117,6 +155,7 @@ impl CCDSolver {
         colliders: &ColliderSet,
         broad_phase: &mut BroadPhaseBvh,
         narrow_phase: &NarrowPhase,
+        hooks: &dyn PhysicsHooks,
     ) -> Option<Real> {
         // Update the query pipeline with the colliders’ predicted positions.
         for (handle, co) in colliders.iter_enabled() {
@@ -199,6 +238,12 @@ impl CCDSolver {
                                 continue;
                             }
 
+                            if pair_filtered_out_by_hooks(
+                                hooks, bodies, colliders, co1, co2, *ch1, ch2, bh1, bh2,
+                            ) {
+                                continue;
+                            }
+
                             let smallest_dist = narrow_phase
                                 .contact_pair(*ch1, ch2)
                                 .and_then(|p| p.find_deepest_contact())
@@ -242,6 +287,7 @@ impl CCDSolver {
         colliders: &ColliderSet,
         broad_phase: &mut BroadPhaseBvh,
         narrow_phase: &NarrowPhase,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
     ) -> PredictedImpacts {
         let dt = params.dt;
@@ -325,6 +371,12 @@ impl CCDSolver {
                                 continue;
                             }
 
+                            if pair_filtered_out_by_hooks(
+                                hooks, bodies, colliders, co1, co2, *ch1, ch2, bh1, bh2,
+                            ) {
+                                continue;
+                            }
+
                             let smallest_dist = narrow_phase
                                 .contact_pair(*ch1, ch2)
                                 .and_then(|p| p.find_deepest_contact())
@@ -442,6 +494,12 @@ impl CCDSolver {
                         continue;
                     }
 
+                    if pair_filtered_out_by_hooks(
+                        hooks, bodies, colliders, co1, co2, *ch1, ch2, bh1, bh2,
+                    ) {
+                        continue;
+                    }
+
                     let frozen1 = bh1.and_then(|h| frozen.get(&h));
                     let frozen2 = bh2.and_then(|h| frozen.get(&h));
 

src/pipeline/physics_pipeline.rs

@@ -374,6 +374,7 @@ impl PhysicsPipeline {
         broad_phase: &mut BroadPhaseBvh,
         narrow_phase: &NarrowPhase,
         ccd_solver: &mut CCDSolver,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
     ) {
         self.counters.ccd.toi_computation_time.start();
@@ -385,6 +386,7 @@ impl PhysicsPipeline {
             colliders,
             broad_phase,
             narrow_phase,
+            hooks,
             events,
         );
         ccd_solver.clamp_motions(integration_parameters.dt, bodies, &impacts);
@@ -638,6 +640,7 @@ impl PhysicsPipeline {
                         colliders,
                         broad_phase,
                         narrow_phase,
+                        hooks,
                     )
                 } else {
                     None
@@ -709,6 +712,7 @@ impl PhysicsPipeline {
                         broad_phase,
                         narrow_phase,
                         ccd_solver,
+                        hooks,
                         events,
                     );
                 }
@@ -954,6 +958,100 @@ mod test {
         assert_eq!(h3a, h3b);
     }
 
+    // Regression test for https://github.com/dimforge/rapier/issues/754 —
+    // CCD must consult `filter_contact_pair` just like the narrow phase, so
+    // pairs the user filtered out don't clamp a fast CCD body's motion.
+    #[test]
+    #[cfg(feature = "dim3")]
+    fn ccd_respects_filter_contact_pair_hook() {
+        use crate::pipeline::{ActiveHooks, PairFilterContext, PhysicsHooks};
+        use crate::prelude::{ColliderHandle, SolverFlags};
+        use core::sync::atomic::{AtomicUsize, Ordering};
+
+        struct RejectAllHooks {
+            calls: AtomicUsize,
+        }
+        impl PhysicsHooks for RejectAllHooks {
+            fn filter_contact_pair(&self, _: &PairFilterContext) -> Option<SolverFlags> {
+                self.calls.fetch_add(1, Ordering::Relaxed);
+                None // reject every pair
+            }
+        }
+
+        let mut pipeline = PhysicsPipeline::new();
+        let integration_parameters = IntegrationParameters::default();
+        let mut broad_phase = BroadPhaseBvh::new();
+        let mut narrow_phase = NarrowPhase::new();
+        let mut bodies = RigidBodySet::new();
+        let mut colliders = ColliderSet::new();
+        let mut ccd = CCDSolver::new();
+        let mut impulse_joints = ImpulseJointSet::new();
+        let mut multibody_joints = MultibodyJointSet::new();
+        let mut islands = IslandManager::new();
+        let hooks = RejectAllHooks { calls: AtomicUsize::new(0) };
+        let event_handler = ();
+
+        // Body A: fast-moving, CCD-enabled.
+        let body_a = RigidBodyBuilder::dynamic()
+            .translation(Vector::new(-5.0, 0.0, 0.0))
+            .linvel(Vector::new(200.0, 0.0, 0.0))
+            .ccd_enabled(true)
+            .build();
+        let a_handle = bodies.insert(body_a);
+        let _: ColliderHandle = colliders.insert_with_parent(
+            ColliderBuilder::ball(0.5)
+                .active_hooks(ActiveHooks::FILTER_CONTACT_PAIRS)
+                .build(),
+            a_handle,
+            &mut bodies,
+        );
+
+        // Body B: stationary, CCD-enabled, at origin.
+        let body_b = RigidBodyBuilder::dynamic().ccd_enabled(true).build();
+        let b_handle = bodies.insert(body_b);
+        let _: ColliderHandle = colliders.insert_with_parent(
+            ColliderBuilder::ball(0.5)
+                .active_hooks(ActiveHooks::FILTER_CONTACT_PAIRS)
+                .build(),
+            b_handle,
+            &mut bodies,
+        );
+
+        for _ in 0..5 {
+            pipeline.step(
+                Vector::ZERO,
+                &integration_parameters,
+                &mut islands,
+                &mut broad_phase,
+                &mut narrow_phase,
+                &mut bodies,
+                &mut colliders,
+                &mut impulse_joints,
+                &mut multibody_joints,
+                &mut ccd,
+                &hooks,
+                &event_handler,
+            );
+        }
+
+        // Hook must be called at least once (from CCD, since they never
+        // reach narrow-phase contact in a single step at 200 m/s × 1/60s).
+        assert!(
+            hooks.calls.load(Ordering::Relaxed) > 0,
+            "filter_contact_pair was never called",
+        );
+
+        // Without the fix: CCD clamps A's motion at the predicted impact
+        // with B (hook ignored). A stalls near B.
+        // With the fix: A flies straight through at 200 m/s for 5 steps of
+        // dt=1/60s ≈ 16.67 units, so it ends near +11.67.
+        let a_pos = bodies[a_handle].translation().x;
+        assert!(
+            a_pos > 10.0,
+            "body A should have passed through filtered body B, but x={a_pos}",
+        );
+    }
+
     #[test]
     fn collider_removal_before_step() {
         let mut pipeline = PhysicsPipeline::new();