Add predicate variants to all casts

src/spatial_query/pipeline.rs

@@ -169,22 +169,14 @@ impl SpatialQueryPipeline {
         solid: bool,
         query_filter: &SpatialQueryFilter,
     ) -> Option<RayHitData> {
-        let pipeline_shape = self.as_composite_shape(query_filter);
-        let ray = parry::query::Ray::new(origin.into(), direction.adjust_precision().into());
-        let mut visitor = RayCompositeShapeToiAndNormalBestFirstVisitor::new(
-            &pipeline_shape,
-            &ray,
+        self.cast_ray_predicate(
+            origin,
+            direction,
             max_time_of_impact,
             solid,
-        );
-
-        self.qbvh
-            .traverse_best_first(&mut visitor)
-            .map(|(_, (entity_index, hit))| RayHitData {
-                entity: self.entity_from_index(entity_index),
-                time_of_impact: hit.time_of_impact,
-                normal: hit.normal.into(),
-            })
+            query_filter,
+            &|_| true,
+        )
     }
 
     /// Casts a [ray](spatial_query#raycasting) and computes the closest [hit](RayHitData) with a collider.
@@ -354,6 +346,50 @@ impl SpatialQueryPipeline {
         max_time_of_impact: Scalar,
         ignore_origin_penetration: bool,
         query_filter: &SpatialQueryFilter,
+    ) -> Option<ShapeHitData> {
+        self.cast_shape_predicate(
+            shape,
+            origin,
+            shape_rotation,
+            direction,
+            max_time_of_impact,
+            ignore_origin_penetration,
+            query_filter,
+            &|_| true,
+        )
+    }
+
+    /// Casts a [shape](spatial_query#shapecasting) with a given rotation and computes the closest [hit](ShapeHits)
+    /// with a collider. If there are no hits, `None` is returned.
+    ///
+    /// For a more ECS-based approach, consider using the [`ShapeCaster`] component instead.
+    ///
+    /// ## Arguments
+    ///
+    /// - `shape`: The shape being cast represented as a [`Collider`].
+    /// - `origin`: Where the shape is cast from.
+    /// - `shape_rotation`: The rotation of the shape being cast.
+    /// - `direction`: What direction the shape is cast in.
+    /// - `max_time_of_impact`: The maximum distance that the shape can travel.
+    /// - `ignore_origin_penetration`: If true and the shape is already penetrating a collider at the
+    ///     shape origin, the hit will be ignored and only the next hit will be computed. Otherwise, the initial
+    ///     hit will be returned.
+    /// - `query_filter`: A [`SpatialQueryFilter`] that determines which colliders are taken into account in the query.
+    /// - `predicate`: A function with which the colliders are filtered. Given the Entity it should return false, if the
+    ///     entity should be ignored.
+    ///
+    /// See also: [`SpatialQuery::cast_shape`]
+    #[allow(clippy::too_many_arguments)]
+    pub fn cast_shape_predicate(
+        &self,
+        shape: &Collider,
+        origin: Vector,
+        shape_rotation: RotationValue,
+        direction: Dir,
+        max_time_of_impact: Scalar,
+        ignore_origin_penetration: bool,
+        query_filter: &SpatialQueryFilter,
+        predicate: &dyn Fn(Entity) -> bool,
     ) -> Option<ShapeHitData> {
         let rotation: Rotation;
         #[cfg(feature = "2d")]
@@ -367,7 +403,7 @@ impl SpatialQueryPipeline {
 
         let shape_isometry = make_isometry(origin, rotation);
         let shape_direction = direction.adjust_precision().into();
-        let pipeline_shape = self.as_composite_shape(query_filter);
+        let pipeline_shape = self.as_composite_shape_with_predicate(query_filter, predicate);
         let mut visitor = TOICompositeShapeShapeBestFirstVisitor::new(
             &*self.dispatcher,
             &shape_isometry,
@@ -542,9 +578,32 @@ impl SpatialQueryPipeline {
         point: Vector,
         solid: bool,
         query_filter: &SpatialQueryFilter,
+    ) -> Option<PointProjection> {
+        self.project_point_predicate(point, solid, query_filter, &|_| true)
+    }
+
+    /// Finds the [projection](spatial_query#point-projection) of a given point on the closest [collider](Collider).
+    /// If one isn't found, `None` is returned.
+    ///
+    /// ## Arguments
+    ///
+    /// - `point`: The point that should be projected.
+    /// - `solid`: If true and the point is inside of a collider, the projection will be at the point.
+    ///     Otherwise, the collider will be treated as hollow, and the projection will be at the collider's boundary.
+    /// - `query_filter`: A [`SpatialQueryFilter`] that determines which colliders are taken into account in the query.
+    /// - `predicate`: A function with which the colliders are filtered. Given the Entity it should return false, if the
+    ///     entity should be ignored.
+    ///
+    /// See also: [`SpatialQuery::project_point`]
+    pub fn project_point_predicate(
+        &self,
+        point: Vector,
+        solid: bool,
+        query_filter: &SpatialQueryFilter,
+        predicate: &dyn Fn(Entity) -> bool,
     ) -> Option<PointProjection> {
         let point = point.into();
-        let pipeline_shape = self.as_composite_shape(query_filter);
+        let pipeline_shape = self.as_composite_shape_with_predicate(query_filter, predicate);
         let mut visitor =
             PointCompositeShapeProjBestFirstVisitor::new(&pipeline_shape, &point, solid);