Modify BroadPhasePairFilter to accept set

src/pipeline/broad_phase/broad_phase_pair_filter.rs

@@ -1,14 +1,27 @@
+use crate::pipeline::object::CollisionObjectSet;
 use na::RealField;
 use std::any::Any;
 
 /// A signal handler for contact detection.
-pub trait BroadPhasePairFilter<N: RealField, Object, Handle>: Any + Send + Sync {
+pub trait BroadPhasePairFilter<N: RealField, Set: CollisionObjectSet<N>>:
+    Any + Send + Sync
+{
     /// Activate an action for when two objects start or stop to be close to each other.
-    fn is_pair_valid(&self, b1: &Object, b2: &Object, h1: Handle, h2: Handle) -> bool;
+    fn is_pair_valid(
+        &self,
+        h1: Set::CollisionObjectHandle,
+        h2: Set::CollisionObjectHandle,
+        s: &Set,
+    ) -> bool;
 }
 
-impl<N: RealField, Object, Handle> BroadPhasePairFilter<N, Object, Handle> for () {
-    fn is_pair_valid(&self, _: &Object, _: &Object, _: Handle, _: Handle) -> bool {
+impl<N: RealField, Set: CollisionObjectSet<N>> BroadPhasePairFilter<N, Set> for () {
+    fn is_pair_valid(
+        &self,
+        _: Set::CollisionObjectHandle,
+        _: Set::CollisionObjectHandle,
+        _: &Set,
+    ) -> bool {
         true
     }
 }

src/pipeline/glue/update.rs

@@ -11,8 +11,7 @@ struct CollisionWorldInterferenceHandler<'a, 'b, N, Objects, Filter>
 where
     N: RealField,
     Objects: CollisionObjectSet<N>,
-    Filter:
-        BroadPhasePairFilter<N, Objects::CollisionObject, Objects::CollisionObjectHandle> + ?Sized,
+    Filter: BroadPhasePairFilter<N, Objects> + ?Sized,
 {
     narrow_phase: &'b mut NarrowPhase<N, Objects::CollisionObjectHandle>,
     interactions: &'b mut InteractionGraph<N, Objects::CollisionObjectHandle>,
@@ -25,22 +24,19 @@ impl<'a, 'b, N: RealField, Objects, Filter>
     for CollisionWorldInterferenceHandler<'a, 'b, N, Objects, Filter>
 where
     Objects: CollisionObjectSet<N>,
-    Filter:
-        BroadPhasePairFilter<N, Objects::CollisionObject, Objects::CollisionObjectHandle> + ?Sized,
+    Filter: BroadPhasePairFilter<N, Objects> + ?Sized,
 {
     fn is_interference_allowed(
         &mut self,
         b1: &Objects::CollisionObjectHandle,
         b2: &Objects::CollisionObjectHandle,
     ) -> bool {
-        let o1 = try_ret!(self.objects.collision_object(*b1), false);
-        let o2 = try_ret!(self.objects.collision_object(*b2), false);
         let filter_by_groups = CollisionGroupsPairFilter;
 
-        filter_by_groups.is_pair_valid(o1, o2, *b1, *b2)
+        filter_by_groups.is_pair_valid(*b1, *b2, self.objects)
             && self
                 .pair_filters
-                .map(|f| f.is_pair_valid(o1, o2, *b1, *b2))
+                .map(|f| f.is_pair_valid(*b1, *b2, self.objects))
                 .unwrap_or(true)
     }
 
@@ -72,10 +68,7 @@ pub fn perform_broad_phase<N: RealField, Objects>(
     broad_phase: &mut (impl BroadPhase<N, AABB<N>, Objects::CollisionObjectHandle> + ?Sized),
     narrow_phase: &mut NarrowPhase<N, Objects::CollisionObjectHandle>,
     interactions: &mut InteractionGraph<N, Objects::CollisionObjectHandle>,
-    pair_filters: Option<
-        &(impl BroadPhasePairFilter<N, Objects::CollisionObject, Objects::CollisionObjectHandle>
-              + ?Sized),
-    >,
+    pair_filters: Option<&(impl BroadPhasePairFilter<N, Objects> + ?Sized)>,
 ) where
     Objects: CollisionObjectSet<N>,
 {
@@ -126,10 +119,7 @@ pub fn perform_all_pipeline<'a, N, Objects>(
     broad_phase: &mut (impl BroadPhase<N, AABB<N>, Objects::CollisionObjectHandle> + ?Sized),
     narrow_phase: &mut NarrowPhase<N, Objects::CollisionObjectHandle>,
     interactions: &mut InteractionGraph<N, Objects::CollisionObjectHandle>,
-    pair_filters: Option<
-        &'a (impl BroadPhasePairFilter<N, Objects::CollisionObject, Objects::CollisionObjectHandle>
-                 + ?Sized),
-    >,
+    pair_filters: Option<&'a (impl BroadPhasePairFilter<N, Objects> + ?Sized)>,
 ) where
     N: RealField,
     Objects: CollisionObjectSet<N>,

src/pipeline/object/collision_groups.rs

@@ -1,5 +1,5 @@
 use crate::pipeline::broad_phase::BroadPhasePairFilter;
-use crate::pipeline::object::{CollisionObjectHandle, CollisionObjectRef};
+use crate::pipeline::object::{CollisionObjectRef, CollisionObjectSet};
 use na::RealField;
 
 const SELF_COLLISION: u32 = 1 << 31;
@@ -383,10 +383,18 @@ impl CollisionGroupsPairFilter {
     }
 }
 
-impl<N: RealField, Object: CollisionObjectRef<N>, Handle: CollisionObjectHandle>
-    BroadPhasePairFilter<N, Object, Handle> for CollisionGroupsPairFilter
+impl<N: RealField, Set: CollisionObjectSet<N>> BroadPhasePairFilter<N, Set>
+    for CollisionGroupsPairFilter
 {
-    fn is_pair_valid(&self, co1: &Object, co2: &Object, h1: Handle, h2: Handle) -> bool {
+    fn is_pair_valid(
+        &self,
+        h1: Set::CollisionObjectHandle,
+        h2: Set::CollisionObjectHandle,
+        s: &Set,
+    ) -> bool {
+        let co1 = try_ret!(s.collision_object(h1), false);
+        let co2 = try_ret!(s.collision_object(h2), false);
+
         if h1 == h2 {
             co1.collision_groups().can_interact_with_self()
         } else {

src/pipeline/world.rs

@@ -37,8 +37,7 @@ pub struct CollisionWorld<N: RealField, T> {
     /// The graph of interactions detected so far.
     pub interactions: InteractionGraph<N, CollisionObjectSlabHandle>,
     /// A user-defined broad-phase pair filter.
-    pub pair_filters:
-        Option<Box<dyn BroadPhasePairFilter<N, CollisionObject<N, T>, CollisionObjectSlabHandle>>>,
+    pub pair_filters: Option<Box<dyn BroadPhasePairFilter<N, CollisionObjectSlab<N, T>>>>,
 }
 
 impl<N: RealField, T> CollisionWorld<N, T> {
@@ -210,14 +209,10 @@ impl<N: RealField, T> CollisionWorld<N, T> {
     /// collision pairs.
     pub fn set_broad_phase_pair_filter<F>(&mut self, filter: Option<F>)
     where
-        F: BroadPhasePairFilter<N, CollisionObject<N, T>, CollisionObjectSlabHandle>,
+        F: BroadPhasePairFilter<N, CollisionObjectSlab<N, T>>,
     {
-        self.pair_filters = filter.map(|f| {
-            Box::new(f)
-                as Box<
-                    dyn BroadPhasePairFilter<N, CollisionObject<N, T>, CollisionObjectSlabHandle>,
-                >
-        });
+        self.pair_filters = filter
+            .map(|f| Box::new(f) as Box<dyn BroadPhasePairFilter<N, CollisionObjectSlab<N, T>>>);
         self.broad_phase.deferred_recompute_all_proximities();
     }