wip: using point query options as dyn ; dispatching them depending on shapes knowing their underlying algorithm.

Author: ThierryBerger

crates/parry2d/examples/project_point2d.rs

@@ -38,6 +38,7 @@ async fn main() {
             &Isometry::from_parts(translation, rot),
             &na_from_mquad(point_to_project),
             true,
+            &(),
         );
 
         /*
@@ -66,7 +67,8 @@ async fn main() {
 
         // fixed local point inside the shape
         let point_to_project = Vec2::ZERO;
-        let projected_point = trimesh.project_local_point(&na_from_mquad(point_to_project), true);
+        let projected_point =
+            trimesh.project_local_point(&na_from_mquad(point_to_project), true, &());
         let color = if projected_point.is_inside {
             RED
         } else {

crates/parry2d/examples/solid_point_query2d.rs

@@ -9,25 +9,26 @@ fn main() {
     let pt_inside = Point2::origin();
     let pt_outside = Point2::new(2.0, 2.0);
 
+    let options = &();
     // Solid projection.
     assert_eq!(
-        cuboid.distance_to_point(&Isometry2::identity(), &pt_inside, true),
+        cuboid.distance_to_point(&Isometry2::identity(), &pt_inside, true, options),
         0.0
     );
 
     // Non-solid projection.
     assert_eq!(
-        cuboid.distance_to_point(&Isometry2::identity(), &pt_inside, false),
+        cuboid.distance_to_point(&Isometry2::identity(), &pt_inside, false, options),
         -1.0
     );
 
     // The other point is outside of the cuboid so the `solid` flag has no effect.
     assert_eq!(
-        cuboid.distance_to_point(&Isometry2::identity(), &pt_outside, false),
+        cuboid.distance_to_point(&Isometry2::identity(), &pt_outside, false, options),
         1.0
     );
     assert_eq!(
-        cuboid.distance_to_point(&Isometry2::identity(), &pt_outside, true),
+        cuboid.distance_to_point(&Isometry2::identity(), &pt_outside, true, options),
         1.0
     );
 }

crates/parry2d/tests/geometry/epa2.rs

@@ -1,4 +1,5 @@
 use na::{self, Isometry2, Vector2};
+use parry2d::query::gjk::GjkOptions;
 use parry2d::query::{self, ContactManifold, DefaultQueryDispatcher, PersistentQueryDispatcher};
 use parry2d::shape::Cuboid;
 
@@ -8,15 +9,17 @@ fn cuboid_cuboid_EPA() {
     let c = Cuboid::new(Vector2::new(2.0, 1.0));
     let m1 = Isometry2::translation(3.5, 0.0);
     let m2 = Isometry2::identity();
-
-    let res = query::details::contact_support_map_support_map(&m1.inv_mul(&m2), &c, &c, 10.0)
-        .expect("Penetration not found.");
+    let options = GjkOptions::default();
+    let res =
+        query::details::contact_support_map_support_map(&m1.inv_mul(&m2), &c, &c, 10.0, &options)
+            .expect("Penetration not found.");
     assert_eq!(res.dist, -0.5);
     assert_eq!(res.normal1, -Vector2::x_axis());
 
     let m1 = Isometry2::translation(0.0, 0.2);
-    let res = query::details::contact_support_map_support_map(&m1.inv_mul(&m2), &c, &c, 10.0)
-        .expect("Penetration not found.");
+    let res =
+        query::details::contact_support_map_support_map(&m1.inv_mul(&m2), &c, &c, 10.0, &options)
+            .expect("Penetration not found.");
     assert_eq!(res.dist, -1.8);
     assert_eq!(res.normal1, -Vector2::y_axis());
 }

crates/parry2d/tests/geometry/epa_convergence.rs

@@ -1,7 +1,7 @@
 use na::Vector2;
 use parry2d::{
     math::{Isometry, Point, Real},
-    query,
+    query::{self, gjk::GjkOptions},
     shape::{Capsule, ConvexPolygon, SharedShape},
 };
 
@@ -23,6 +23,7 @@ fn capsule_convergence() {
         &shape1,
         &shape2,
         10.0,
+        &GjkOptions::default(),
     )
     .expect("Penetration not found.");
     let shared_shape1 = SharedShape::new(shape1);

crates/parry2d/tests/query/point_composite_shape.rs

@@ -1,5 +1,8 @@
 use na::Point2;
-use parry2d::{query::PointQuery, shape::TriMesh};
+use parry2d::{
+    query::{gjk::GjkOptions, PointQuery},
+    shape::TriMesh,
+};
 
 #[test]
 fn project_local_point_and_get_feature_gets_the_enclosing_triangle() {
@@ -11,14 +14,15 @@ fn project_local_point_and_get_feature_gets_the_enclosing_triangle() {
     ];
 
     let mesh = TriMesh::new(vertices, vec![[0, 1, 2], [3, 0, 2]]).unwrap();
+    let options = &();
     let query_pt = Point2::new(0.6, 0.6); // Inside the top-right triangle (index 1)
 
-    let (proj, feat) = mesh.project_local_point_and_get_feature(&query_pt);
+    let (proj, feat) = mesh.project_local_point_and_get_feature(&query_pt, options);
 
     let correct_tri_idx = 1;
     let correct_tri = mesh.triangle(correct_tri_idx);
 
-    let is_inside_correct = correct_tri.contains_local_point(&query_pt);
+    let is_inside_correct = correct_tri.contains_local_point(&query_pt, options);
 
     assert!(is_inside_correct);
     assert_eq!(proj.is_inside, is_inside_correct);
@@ -35,16 +39,16 @@ fn project_local_point_and_get_feature_projects_correctly_from_outside() {
     ];
 
     let mesh = TriMesh::new(vertices, vec![[0, 1, 2], [3, 0, 2]]).unwrap();
-
+    let options = &();
     {
         let query_pt = Point2::new(-1.0, 0.0); // Left from the bottom-left triangle (index 0)
 
-        let (proj, feat) = mesh.project_local_point_and_get_feature(&query_pt);
+        let (proj, feat) = mesh.project_local_point_and_get_feature(&query_pt, options);
 
         let correct_tri_idx = 0;
         let correct_tri = mesh.triangle(correct_tri_idx);
 
-        let is_inside_correct = correct_tri.contains_local_point(&query_pt);
+        let is_inside_correct = correct_tri.contains_local_point(&query_pt, options);
 
         assert_eq!(is_inside_correct, false);
         assert_eq!(proj.is_inside, is_inside_correct);
@@ -54,12 +58,12 @@ fn project_local_point_and_get_feature_projects_correctly_from_outside() {
     {
         let query_pt = Point2::new(0.5, 2.0); // Above the top-right triangle (index 1)
 
-        let (proj, feat) = mesh.project_local_point_and_get_feature(&query_pt);
+        let (proj, feat) = mesh.project_local_point_and_get_feature(&query_pt, options);
 
         let correct_tri_idx = 1;
         let correct_tri = mesh.triangle(correct_tri_idx);
 
-        let is_inside_correct = correct_tri.contains_local_point(&query_pt);
+        let is_inside_correct = correct_tri.contains_local_point(&query_pt, options);
 
         assert_eq!(is_inside_correct, false);
         assert_eq!(proj.is_inside, is_inside_correct);

crates/parry2d/tests/query/point_triangle.rs

@@ -12,8 +12,8 @@ fn project_local_point_point_on_ab() {
 
     let query_pt = Point::new(1.4, 1.0);
 
-    let proj1 = tri1.project_local_point(&query_pt, false); // Used to fail on 0.14 and earlier
-    let proj2 = tri2.project_local_point(&query_pt, false);
+    let proj1 = tri1.project_local_point(&query_pt, false, &()); // Used to fail on 0.14 and earlier
+    let proj2 = tri2.project_local_point(&query_pt, false, &());
 
     assert_eq!(proj1.point, proj2.point);
     assert_eq!(proj1.point, query_pt);

crates/parry3d/examples/project_point3d.rs

@@ -24,7 +24,8 @@ async fn main() {
         let slow_elapsed_time = elapsed_time / 3.0;
 
         let point_to_project = lissajous_3d(slow_elapsed_time);
-        let projected_point = trimesh.project_local_point(&na_from_mquad(point_to_project), true);
+        let projected_point =
+            trimesh.project_local_point(&na_from_mquad(point_to_project), true, &());
 
         let slow_elapsed_time = slow_elapsed_time * 0.7;
         // Setup 3D camera.
@@ -65,7 +66,8 @@ async fn main() {
 
         // fixed point inside the shape
         let point_to_project = Vec3::ZERO;
-        let projected_point = trimesh.project_local_point(&na_from_mquad(point_to_project), true);
+        let projected_point =
+            trimesh.project_local_point(&na_from_mquad(point_to_project), true, &());
         let color = if projected_point.is_inside {
             RED
         } else {

crates/parry3d/examples/solid_point_query3d.rs

@@ -8,26 +8,27 @@ fn main() {
     let cuboid = Cuboid::new(Vector3::new(1.0, 2.0, 2.0));
     let pt_inside = Point3::origin();
     let pt_outside = Point3::new(2.0, 2.0, 2.0);
+    let options = &();
 
     // Solid projection.
     assert_eq!(
-        cuboid.distance_to_point(&Isometry3::identity(), &pt_inside, true),
+        cuboid.distance_to_point(&Isometry3::identity(), &pt_inside, true, options),
         0.0
     );
 
     // Non-solid projection.
     assert_eq!(
-        cuboid.distance_to_point(&Isometry3::identity(), &pt_inside, false),
+        cuboid.distance_to_point(&Isometry3::identity(), &pt_inside, false, options),
         -1.0
     );
 
     // The other point is outside of the cuboid so the `solid` flag has no effect.
     assert_eq!(
-        cuboid.distance_to_point(&Isometry3::identity(), &pt_outside, false),
+        cuboid.distance_to_point(&Isometry3::identity(), &pt_outside, false, options),
         1.0
     );
     assert_eq!(
-        cuboid.distance_to_point(&Isometry3::identity(), &pt_outside, true),
+        cuboid.distance_to_point(&Isometry3::identity(), &pt_outside, true, options),
         1.0
     );
 }

crates/parry3d/tests/geometry/cuboid_ray_cast.rs

@@ -42,15 +42,15 @@ where
         let point_nudged_out = point + intersection.normal * 0.001;
 
         assert!(
-            shape.contains_point(&position, &point_nudged_in),
+            shape.contains_point(&position, &point_nudged_in, &()),
             "Shape {} rotated with {:#?} does not contain point nudged in {:#?}",
             name,
             rotation.axis(),
             point_nudged_in,
         );
 
         assert!(
-            !shape.contains_point(&position, &point_nudged_out),
+            !shape.contains_point(&position, &point_nudged_out, &()),
             "Shape {} rotated with {:#?} does contains point nudged out {:#?}",
             name,
             rotation.axis(),

crates/parry3d/tests/geometry/cylinder_cuboid_contact.rs

@@ -1,5 +1,6 @@
 use na::{self, Isometry3, Vector3};
 use parry3d::query;
+use parry3d::query::gjk::GjkOptions;
 use parry3d::shape::{Cuboid, Cylinder};
 
 // Issue #157.
@@ -9,23 +10,28 @@ fn cylinder_cuboid_contact() {
     let cyl_at = Isometry3::translation(10.97, 0.925, 61.02);
     let cuboid = Cuboid::new(Vector3::new(0.05, 0.75, 0.5));
     let cuboid_at = Isometry3::translation(11.50, 0.75, 60.5);
+    let options = GjkOptions::default();
+
     let distance = query::details::distance_support_map_support_map(
         &cyl_at.inv_mul(&cuboid_at),
         &cyl,
         &cuboid,
+        &options,
     );
 
     let intersecting = query::details::intersection_test_support_map_support_map(
         &cyl_at.inv_mul(&cuboid_at),
         &cyl,
         &cuboid,
+        &options,
     );
 
     let contact = query::details::contact_support_map_support_map(
         &cyl_at.inv_mul(&cuboid_at),
         &cyl,
         &cuboid,
         10.0,
+        &options,
     );
 
     assert!(distance == 0.0);