add an example to test out API for compound shape options

ThierryBerger · ThierryBerger · commit 02a37ec89a3e · 2025-07-09T10:38:30.000+02:00
It's not straightforward to do, that will likely need a solution similar to a dispatcher
diff --git a/crates/parry2d/Cargo.toml b/crates/parry2d/Cargo.toml
@@ -93,6 +93,7 @@ oorandom = "11"
 ptree = "0.4.0"
 rand = { version = "0.8" }
 macroquad = "0.4.12"
+env_logger = "0.11"
 
 [package.metadata.docs.rs]
 rustdoc-args = ["-Zunstable-options", "--generate-link-to-definition"]
@@ -162,6 +163,11 @@ name = "point_in_poly2d"
 path = "examples/point_in_poly2d.rs"
 doc-scrape-examples = true
 
+[[example]]
+name = "point_query2d"
+path = "examples/point_query2d.rs"
+doc-scrape-examples = true
+
 [[example]]
 name = "polygons_intersection2d"
 path = "examples/polygons_intersection2d.rs"
diff --git a/crates/parry2d/examples/debug_shape_cast2d.rs b/crates/parry2d/examples/debug_shape_cast2d.rs
@@ -4,7 +4,6 @@ use common_macroquad2d::draw_point;
 use macroquad::prelude::*;
 use nalgebra::{Isometry2, Point2};
 use parry2d::math::{self, Isometry};
-use parry2d::query::gjk::eps_tol;
 use parry2d::query::{self, DefaultQueryDispatcher, Ray, ShapeCastOptions};
 use parry2d::shape::{Ball, ConvexPolygon, Shape};
 
diff --git a/crates/parry2d/examples/point_query2d.rs b/crates/parry2d/examples/point_query2d.rs
@@ -0,0 +1,93 @@
+//! Builds on top of `point_in_poly2d` example but uses `QueryPoint`` methods and different shapes.
+
+mod common_macroquad2d;
+
+use common_macroquad2d::{draw_point, draw_polygon};
+use macroquad::prelude::*;
+use nalgebra::{Isometry, Point2, Rotation, Translation, UnitComplex, Vector2};
+use parry2d::query::PointQuery;
+use parry2d::shape::{ConvexPolygon, Shape, SharedShape};
+use parry2d::{shape::Compound, utils::point_in_poly2d};
+
+const RENDER_SCALE: f32 = 30.0;
+
+#[macroquad::main("points_in_poly2d")]
+async fn main() {
+    env_logger::init();
+    let mut compound_simple = simple_compound();
+    let mut compound_simple2 = simple_compound();
+    let test_points = grid_points();
+
+    let animation_rotation = UnitComplex::new(0.02);
+    let polygon_render_pos = Point2::new(screen_width() / 2.0, screen_height() / 2.0);
+
+    for i in 0.. {
+        let shape_to_query = if (i / 350) % 2 == 0 {
+            &mut compound_simple
+        } else {
+            &mut compound_simple2
+        };
+
+        clear_background(BLACK);
+
+        // TODO: Display the shape
+        /*         polygon
+                    .iter_mut()
+                    .for_each(|pt| *pt = animation_rotation * *pt);
+
+                draw_polygon(&polygon, RENDER_SCALE, polygon_render_pos, BLUE);
+        */
+        /*
+         * Compute polygon intersections.
+         */
+        for point in &test_points {
+            let pos12 = Isometry::default().inv_mul(&Isometry::from_parts(
+                Translation::from(point.coords),
+                Rotation::identity(),
+            ));
+            if shape_to_query.contains_local_point(
+                &(pos12 * point),
+                // FIXME: Thierry (pr 298): options should contain everything necessary to be dispatched.
+                &(),
+            ) {
+                draw_point(*point, RENDER_SCALE, polygon_render_pos, RED);
+            } else {
+                draw_point(*point, RENDER_SCALE, polygon_render_pos, GREEN);
+            }
+        }
+
+        next_frame().await
+    }
+}
+
+fn simple_compound() -> Box<dyn Shape> {
+    let to_cast_against = ConvexPolygon::from_convex_polyline(
+        [
+            [-24.0, 0.0].into(),
+            [0.0, -24.0].into(),
+            [24.0, 0.0].into(),
+            [0.0, 24.0].into(),
+        ]
+        .into(),
+    )
+    .unwrap();
+    Box::new(Compound::new(vec![(
+        Isometry::default(),
+        SharedShape::new(to_cast_against),
+    )]))
+}
+
+fn grid_points() -> Vec<Point2<f32>> {
+    let count = 80 * 5;
+    let spacing = 0.6 / 5.0;
+    let mut pts = vec![];
+    for i in 0..count {
+        for j in 0..count {
+            pts.push(Point2::new(
+                (i as f32 - count as f32 / 2.0) * spacing,
+                (j as f32 - count as f32 / 2.0) * spacing,
+            ));
+        }
+    }
+    pts
+}
diff --git a/crates/parry2d/tests/query/point_composite_shape.rs b/crates/parry2d/tests/query/point_composite_shape.rs
@@ -1,8 +1,5 @@
 use na::Point2;
-use parry2d::{
-    query::{gjk::GjkOptions, PointQuery},
-    shape::TriMesh,
-};
+use parry2d::{query::PointQuery, shape::TriMesh};
 
 #[test]
 fn project_local_point_and_get_feature_gets_the_enclosing_triangle() {
diff --git a/src/query/point/point_round_shape.rs b/src/query/point/point_round_shape.rs
@@ -1,5 +1,7 @@
+use log::warn;
+
 use crate::math::{Point, Real};
-use crate::query::gjk::VoronoiSimplex;
+use crate::query::gjk::{GjkOptions, VoronoiSimplex};
 use crate::query::point::point_query::QueryOptions;
 use crate::query::{PointProjection, PointQuery};
 use crate::shape::{FeatureId, RoundShape, SupportMap};
@@ -18,16 +20,27 @@ impl<S: SupportMap> PointQuery for RoundShape<S> {
         return unimplemented!(
             "The projection of points on a round shapes isn’t supported on no-std platforms yet."
         );
-        let options = options.as_any().downcast_ref().unwrap();
 
         #[cfg(feature = "std")] // TODO: can’t be used without std because of EPA
-        return crate::query::details::local_point_projection_on_support_map(
-            self,
-            &mut VoronoiSimplex::new(),
-            point,
-            solid,
-            options,
-        );
+        {
+            let Some(options) = options.as_any().downcast_ref() else {
+                warn!("Incorrect option passed to project_local_point: using default options.");
+                return crate::query::details::local_point_projection_on_support_map(
+                    self,
+                    &mut VoronoiSimplex::new(),
+                    point,
+                    solid,
+                    &GjkOptions::default(),
+                );
+            };
+            return crate::query::details::local_point_projection_on_support_map(
+                self,
+                &mut VoronoiSimplex::new(),
+                point,
+                solid,
+                options,
+            );
+        }
     }
 
     #[inline]
diff --git a/src/query/point/point_support_map.rs b/src/query/point/point_support_map.rs
@@ -65,12 +65,22 @@ impl PointQuery for ConvexPolyhedron {
         solid: bool,
         options: &dyn QueryOptions,
     ) -> PointProjection {
+        let Some(options) = options.as_any().downcast_ref() else {
+            log::warn!("Incorrect option passed to project_local_point: using default options.");
+            return local_point_projection_on_support_map(
+                self,
+                &mut VoronoiSimplex::new(),
+                point,
+                solid,
+                &GjkOptions::default(),
+            );
+        };
         local_point_projection_on_support_map(
             self,
             &mut VoronoiSimplex::new(),
             point,
             solid,
-            options.as_any().downcast_ref().unwrap(),
+            options,
         )
     }
 
@@ -102,13 +112,24 @@ impl PointQuery for ConvexPolygon {
         solid: bool,
         options: &dyn QueryOptions,
     ) -> PointProjection {
-        local_point_projection_on_support_map(
+        let Some(options) = options.as_any().downcast_ref() else {
+            log::warn!("Incorrect option passed to local_point_projection_on_support_map: using default options.");
+            return local_point_projection_on_support_map(
+                self,
+                &mut VoronoiSimplex::new(),
+                point,
+                solid,
+                &GjkOptions::default(),
+            );
+        };
+
+        return local_point_projection_on_support_map(
             self,
             &mut VoronoiSimplex::new(),
             point,
             solid,
-            options.as_any().downcast_ref().unwrap(),
-        )
+            &options,
+        );
     }
 
     #[inline]
diff --git a/src/query/split/split_trimesh.rs b/src/query/split/split_trimesh.rs
@@ -322,7 +322,6 @@ impl TriMesh {
                     vertices_lhs[idx1[2] as usize],
                 );
 
-                // FIXME: Thierry: pass an option?
                 if self.contains_local_point(&tri.center(), &()) {
                     indices_lhs.push(idx1);
 
diff --git a/src/query/visitors/composite_point_containment_test.rs b/src/query/visitors/composite_point_containment_test.rs
@@ -49,7 +49,7 @@ impl<S: TypedSimdCompositeShape> SimdVisitor<S::PartId, SimdAabb>
                     self.shape.map_typed_part_at(*data, |part_pos, obj, _| {
                         if obj.contains_local_point(
                             &part_pos.inverse_transform_point(self.point),
-                            // FIXME: Thierry: safer type checking
+                            // FIXME: Thierry: passed option should be depending on shape...
                             &(),
                         ) {
                             self.found = true;
diff --git a/src/transformation/mesh_intersection/mesh_intersection.rs b/src/transformation/mesh_intersection/mesh_intersection.rs
@@ -324,7 +324,6 @@ fn extract_connected_components(
                     if flip2
                         ^ mesh2.contains_local_point(
                             &pos12.inverse_transform_point(&tri1.center()),
-                            // FIXME: Thierry: safer type checking
                             &(),
                         )
                     {
@@ -372,12 +371,7 @@ fn extract_connected_components(
                 let repr_pt = mesh1.triangle(repr_face).center();
                 let indices = mesh1.indices();
 
-                if flip2
-                    ^ mesh2.contains_local_point(
-                        &pos12.inverse_transform_point(&repr_pt),
-                        // FIXME: Thierry: safer type checking
-                        &(),
-                    )
+                if flip2 ^ mesh2.contains_local_point(&pos12.inverse_transform_point(&repr_pt), &())
                 {
                     new_indices1.extend(
                         cc.grouped_faces[range[0]..range[1]]
@@ -391,13 +385,7 @@ fn extract_connected_components(
         // Deal with the case where there is no intersection between the meshes.
         let repr_pt = mesh1.triangle(0).center();
 
-        if flip2
-            ^ mesh2.contains_local_point(
-                &pos12.inverse_transform_point(&repr_pt),
-                // FIXME: Thierry: safer type checking
-                &(),
-            )
-        {
+        if flip2 ^ mesh2.contains_local_point(&pos12.inverse_transform_point(&repr_pt), &()) {
             new_indices1.extend_from_slice(mesh1.indices());
         }
     }
diff --git a/src/transformation/mesh_intersection/triangle_triangle_intersection.rs b/src/transformation/mesh_intersection/triangle_triangle_intersection.rs
@@ -231,7 +231,6 @@ fn debug_check_intersections(
 ) {
     let proj = |vect: Vector<Real>| Point2::new(vect.dot(&basis[0]), vect.dot(&basis[1]));
     let mut incorrect = false;
-    // FIXME: Thierry: safer type checking. (associated type?)
     let options = ();
     for pt in intersections {
         if !tri1
