QueryOptions parameters (GjkOptions)

crates/parry2d/examples/debug_shape_cast2d.rs

@@ -4,7 +4,8 @@ use common_macroquad2d::draw_point;
 use macroquad::prelude::*;
 use nalgebra::{Isometry2, Point2};
 use parry2d::math::Isometry;
-use parry2d::query::{self, Ray, ShapeCastOptions};
+use parry2d::query::gjk::eps_tol;
+use parry2d::query::{self, DefaultQueryDispatcher, Ray, ShapeCastOptions};
 use parry2d::shape::{Ball, ConvexPolygon, Shape};
 
 const RENDER_SCALE: f32 = 1.0;
@@ -101,14 +102,17 @@ fn shape_cast_debug(
     let vel2 = [0.0, 0.0];
     let g2 = to_cast_against.clone_dyn();
 
-    let toi = query::cast_shapes(
+    let toi = query::cast_shapes_with_dispatcher(
         &pos1.into(),
         &vel1,
         &g1,
         &pos2.into(),
         &vel2.into(),
         &*g2,
         ShapeCastOptions::with_max_time_of_impact(1.0),
+        DefaultQueryDispatcher {
+            gjk_espilon_tolerance: eps_tol() * 1000f32,
+        },
     )
     .unwrap();
 

crates/parry2d/tests/geometry/epa2.rs

@@ -28,7 +28,7 @@ fn cuboids_large_size_ratio_issue_181() {
 
     let pos_b = Isometry2::new(Vector2::new(5.0, 0.0), 1.5);
 
-    let dispatcher = DefaultQueryDispatcher;
+    let dispatcher = DefaultQueryDispatcher::default();
     let mut p = Vector2::new(0.0, 0.0);
     let mut angle = 0.0;
 

src/query/closest_points/closest_points_shape_shape.rs

@@ -14,7 +14,7 @@ pub fn closest_points(
     max_dist: Real,
 ) -> Result<ClosestPoints, Unsupported> {
     let pos12 = pos1.inv_mul(pos2);
-    DefaultQueryDispatcher
+    DefaultQueryDispatcher::default()
         .closest_points(&pos12, g1, g2, max_dist)
         .map(|res| res.transform_by(pos1, pos2))
 }

src/query/contact/contact_shape_shape.rs

@@ -14,7 +14,7 @@ pub fn contact(
     prediction: Real,
 ) -> Result<Option<Contact>, Unsupported> {
     let pos12 = pos1.inv_mul(pos2);
-    let mut result = DefaultQueryDispatcher.contact(&pos12, g1, g2, prediction);
+    let mut result = DefaultQueryDispatcher::default().contact(&pos12, g1, g2, prediction);
 
     if let Ok(Some(contact)) = &mut result {
         contact.transform_by_mut(pos1, pos2);

src/query/default_query_dispatcher.rs

@@ -1,5 +1,6 @@
 use crate::math::{Isometry, Point, Real, Vector};
 use crate::query::details::ShapeCastOptions;
+use crate::query::gjk;
 use crate::query::{
     self, details::NonlinearShapeCastMode, ClosestPoints, Contact, NonlinearRigidMotion,
     QueryDispatcher, ShapeCastHit, Unsupported,
@@ -14,7 +15,18 @@ use crate::shape::{HalfSpace, Segment, Shape, ShapeType};
 
 /// A dispatcher that exposes built-in queries
 #[derive(Debug, Clone)]
-pub struct DefaultQueryDispatcher;
+pub struct DefaultQueryDispatcher {
+    /// The absolute tolerance used by the GJK algorithm.
+    pub gjk_espilon_tolerance: Real,
+}
+
+impl Default for DefaultQueryDispatcher {
+    fn default() -> Self {
+        Self {
+            gjk_espilon_tolerance: gjk::eps_tol(),
+        }
+    }
+}
 
 impl QueryDispatcher for DefaultQueryDispatcher {
     fn intersection_test(
@@ -333,6 +345,7 @@ impl QueryDispatcher for DefaultQueryDispatcher {
                     s1,
                     s2,
                     options,
+                    self.gjk_espilon_tolerance,
                 ));
             } else if let Some(c1) = shape1.as_composite_shape() {
                 return Ok(query::details::cast_shapes_composite_shape_shape(

src/query/distance/distance.rs

@@ -13,5 +13,5 @@ pub fn distance(
     g2: &dyn Shape,
 ) -> Result<Real, Unsupported> {
     let pos12 = pos1.inv_mul(pos2);
-    DefaultQueryDispatcher.distance(&pos12, g1, g2)
+    DefaultQueryDispatcher::default().distance(&pos12, g1, g2)
 }

src/query/gjk/gjk.rs

@@ -35,7 +35,7 @@ pub enum GJKResult {
 /// The absolute tolerance used by the GJK algorithm.
 pub fn eps_tol() -> Real {
     let _eps = crate::math::DEFAULT_EPSILON;
-    _eps * 10_000.0
+    _eps
 }
 
 /// Projects the origin on the boundary of the given shape.
@@ -197,6 +197,7 @@ pub fn cast_local_ray<G: ?Sized + SupportMap>(
         ray,
         max_time_of_impact,
         simplex,
+        eps_tol(),
     )
 }
 
@@ -210,25 +211,33 @@ pub fn directional_distance<G1, G2>(
     g2: &G2,
     dir: &Vector<Real>,
     simplex: &mut VoronoiSimplex,
+    gjk_espilon_tolerance: Real,
 ) -> Option<(Real, Vector<Real>, Point<Real>, Point<Real>)>
 where
     G1: ?Sized + SupportMap,
     G2: ?Sized + SupportMap,
 {
     let ray = Ray::new(Point::origin(), *dir);
-    minkowski_ray_cast(pos12, g1, g2, &ray, Real::max_value(), simplex).map(
-        |(time_of_impact, normal)| {
-            let witnesses = if !time_of_impact.is_zero() {
-                result(simplex, simplex.dimension() == DIM)
-            } else {
-                // If there is penetration, the witness points
-                // are undefined.
-                (Point::origin(), Point::origin())
-            };
-
-            (time_of_impact, normal, witnesses.0, witnesses.1)
-        },
+    minkowski_ray_cast(
+        pos12,
+        g1,
+        g2,
+        &ray,
+        Real::max_value(),
+        simplex,
+        gjk_espilon_tolerance,
     )
+    .map(|(time_of_impact, normal)| {
+        let witnesses = if !time_of_impact.is_zero() {
+            result(simplex, simplex.dimension() == DIM)
+        } else {
+            // If there is penetration, the witness points
+            // are undefined.
+            (Point::origin(), Point::origin())
+        };
+
+        (time_of_impact, normal, witnesses.0, witnesses.1)
+    })
 }
 
 // Ray-cast on the Minkowski Difference `g1 - pos12 * g2`.
@@ -239,13 +248,14 @@ fn minkowski_ray_cast<G1, G2>(
     ray: &Ray,
     max_time_of_impact: Real,
     simplex: &mut VoronoiSimplex,
+    gjk_espilon_tolerance: Real,
 ) -> Option<(Real, Vector<Real>)>
 where
     G1: ?Sized + SupportMap,
     G2: ?Sized + SupportMap,
 {
     let _eps = crate::math::DEFAULT_EPSILON;
-    let _eps_tol: Real = eps_tol();
+    let _eps_tol: Real = gjk_espilon_tolerance;
     let _eps_rel: Real = ComplexField::sqrt(_eps_tol);
 
     let ray_length = ray.dir.norm();

src/query/intersection_test/intersection_test.rs

@@ -10,5 +10,5 @@ pub fn intersection_test(
     g2: &dyn Shape,
 ) -> Result<bool, Unsupported> {
     let pos12 = pos1.inv_mul(pos2);
-    DefaultQueryDispatcher.intersection_test(&pos12, g1, g2)
+    DefaultQueryDispatcher::default().intersection_test(&pos12, g1, g2)
 }

src/query/mod.rs

@@ -41,7 +41,9 @@ pub use self::point::{PointProjection, PointQuery, PointQueryWithLocation};
 pub use self::query_dispatcher::PersistentQueryDispatcher;
 pub use self::query_dispatcher::{QueryDispatcher, QueryDispatcherChain};
 pub use self::ray::{Ray, RayCast, RayIntersection, SimdRay};
-pub use self::shape_cast::{cast_shapes, ShapeCastHit, ShapeCastOptions, ShapeCastStatus};
+pub use self::shape_cast::{
+    cast_shapes, cast_shapes_with_dispatcher, ShapeCastHit, ShapeCastOptions, ShapeCastStatus,
+};
 pub use self::split::{IntersectResult, SplitResult};
 
 mod clip;

src/query/nonlinear_shape_cast/nonlinear_shape_cast.rs

@@ -29,7 +29,7 @@ pub fn cast_shapes_nonlinear(
     end_time: Real,
     stop_at_penetration: bool,
 ) -> Result<Option<ShapeCastHit>, Unsupported> {
-    DefaultQueryDispatcher.cast_shapes_nonlinear(
+    DefaultQueryDispatcher::default().cast_shapes_nonlinear(
         motion1,
         g1,
         motion2,

src/query/shape_cast/mod.rs

@@ -1,6 +1,8 @@
 //! Implementation details of the `cast_shapes` function.
 
-pub use self::shape_cast::{cast_shapes, ShapeCastHit, ShapeCastOptions, ShapeCastStatus};
+pub use self::shape_cast::{
+    cast_shapes, cast_shapes_with_dispatcher, ShapeCastHit, ShapeCastOptions, ShapeCastStatus,
+};
 pub use self::shape_cast_ball_ball::cast_shapes_ball_ball;
 pub use self::shape_cast_halfspace_support_map::{
     cast_shapes_halfspace_support_map, cast_shapes_support_map_halfspace,

src/query/shape_cast/shape_cast.rs

@@ -149,5 +149,25 @@ pub fn cast_shapes(
 ) -> Result<Option<ShapeCastHit>, Unsupported> {
     let pos12 = pos1.inv_mul(pos2);
     let vel12 = pos1.inverse_transform_vector(&(vel2 - vel1));
-    DefaultQueryDispatcher.cast_shapes(&pos12, &vel12, g1, g2, options)
+    DefaultQueryDispatcher::default().cast_shapes(&pos12, &vel12, g1, g2, options)
+}
+
+/// Computes the smallest time when two shapes under translational movement are separated by a
+/// distance smaller or equal to `distance`.
+///
+/// Returns `0.0` if the objects are touching or closer than `options.target_distance`,
+/// or penetrating.
+pub fn cast_shapes_with_dispatcher(
+    pos1: &Isometry<Real>,
+    vel1: &Vector<Real>,
+    g1: &dyn Shape,
+    pos2: &Isometry<Real>,
+    vel2: &Vector<Real>,
+    g2: &dyn Shape,
+    options: ShapeCastOptions,
+    dispatcher: impl QueryDispatcher,
+) -> Result<Option<ShapeCastHit>, Unsupported> {
+    let pos12 = pos1.inv_mul(pos2);
+    let vel12 = pos1.inverse_transform_vector(&(vel2 - vel1));
+    dispatcher.cast_shapes(&pos12, &vel12, g1, g2, options)
 }

src/query/shape_cast/shape_cast_support_map_support_map.rs

@@ -15,6 +15,7 @@ pub fn cast_shapes_support_map_support_map<G1, G2>(
     g1: &G1,
     g2: &G2,
     options: ShapeCastOptions,
+    gjk_espilon_tolerance: Real,
 ) -> Option<ShapeCastHit>
 where
     G1: ?Sized + SupportMap,
@@ -25,9 +26,23 @@ where
             inner_shape: g1,
             border_radius: options.target_distance,
         };
-        gjk::directional_distance(pos12, &round_g1, g2, vel12, &mut VoronoiSimplex::new())
+        gjk::directional_distance(
+            pos12,
+            &round_g1,
+            g2,
+            vel12,
+            &mut VoronoiSimplex::new(),
+            gjk_espilon_tolerance,
+        )
     } else {
-        gjk::directional_distance(pos12, g1, g2, vel12, &mut VoronoiSimplex::new())
+        gjk::directional_distance(
+            pos12,
+            g1,
+            g2,
+            vel12,
+            &mut VoronoiSimplex::new(),
+            gjk_espilon_tolerance,
+        )
     };
 
     gjk_result.and_then(|(time_of_impact, normal1, witness1, witness2)| {