Struct QueryDispatcherChain

pub struct QueryDispatcherChain<T, U>(/* private fields */);

A chain of two query dispatchers that provides fallback behavior.

This struct is created by calling QueryDispatcher::chain() and allows combining multiple dispatchers into a fallback sequence. When a query is performed:

1. The first dispatcher (T) is tried
2. If it returns Err(Unsupported), the second dispatcher (U) is tried
3. If the second also returns Unsupported, the error is propagated

Use Cases

Dispatcher chains are useful for:

• Custom shapes with default fallback: Handle your custom shapes specifically, but fall back to Parry’s default dispatcher for standard shapes

• Performance optimization: Try a fast specialized algorithm first, fall back to a general but slower algorithm if needed

• Progressive feature support: Layer dispatchers that support different feature sets

• Debugging: Wrap the default dispatcher with a logging dispatcher that passes through

Example

use parry3d::query::{QueryDispatcher, DefaultQueryDispatcher};

// A dispatcher that handles only custom shapes
struct CustomShapeDispatcher;
impl QueryDispatcher for CustomShapeDispatcher {
    fn distance(
        &self,
        pos12: &Isometry<Real>,
        g1: &dyn Shape,
        g2: &dyn Shape,
    ) -> Result<Real, Unsupported> {
        // Try to handle custom shapes
        match (g1.as_any().downcast_ref::<MyShape>(),
               g2.as_any().downcast_ref::<MyShape>()) {
            (Some(s1), Some(s2)) => Ok(custom_distance(s1, s2, pos12)),
            _ => Err(Unsupported), // Let the next dispatcher handle it
        }
    }
    // ... other methods return Err(Unsupported)
}

// Chain: try custom first, fall back to default
let dispatcher = CustomShapeDispatcher.chain(DefaultQueryDispatcher);

// This will use CustomShapeDispatcher if both are MyShape,
// otherwise DefaultQueryDispatcher handles it
let dist = dispatcher.distance(&pos12, shape1, shape2)?;

Performance Note

Chaining has minimal overhead - it’s just two function calls in the worst case. The first dispatcher is always tried first, so place your most likely-to-succeed dispatcher at the front of the chain for best performance.

Multiple Chains

You can chain more than two dispatchers by chaining chains:

let dispatcher = custom1
    .chain(custom2)
    .chain(DefaultQueryDispatcher);

This creates a chain of three dispatchers: custom1 -> custom2 -> DefaultQueryDispatcher.

Trait Implementations

impl<ManifoldData, ContactData, T, U> PersistentQueryDispatcher<ManifoldData, ContactData> for QueryDispatcherChain<T, U>

where T: PersistentQueryDispatcher<ManifoldData, ContactData>, U: PersistentQueryDispatcher<ManifoldData, ContactData>,

fn contact_manifolds( &self, pos12: &Isometry<f32>, g1: &dyn Shape, g2: &dyn Shape, prediction: f32, manifolds: &mut Vec<ContactManifold<ManifoldData, ContactData>>, workspace: &mut Option<ContactManifoldsWorkspace>, ) -> Result<(), Unsupported>

Compute all the contacts between two shapes.

fn contact_manifold_convex_convex( &self, pos12: &Isometry<f32>, g1: &dyn Shape, g2: &dyn Shape, normal_constraints1: Option<&dyn NormalConstraints>, normal_constraints2: Option<&dyn NormalConstraints>, prediction: f32, manifold: &mut ContactManifold<ManifoldData, ContactData>, ) -> Result<(), Unsupported>

Computes the contact-manifold between two convex shapes.

impl<T, U> QueryDispatcher for QueryDispatcherChain<T, U>

where T: QueryDispatcher, U: QueryDispatcher,

fn intersection_test( &self, pos12: &Isometry<f32>, g1: &dyn Shape, g2: &dyn Shape, ) -> Result<bool, Unsupported>

Tests whether two shapes are intersecting.

fn distance( &self, pos12: &Isometry<f32>, g1: &dyn Shape, g2: &dyn Shape, ) -> Result<f32, Unsupported>

Computes the minimum distance separating two shapes.

fn contact( &self, pos12: &Isometry<f32>, g1: &dyn Shape, g2: &dyn Shape, prediction: f32, ) -> Result<Option<Contact>, Unsupported>

Computes one pair of contact points point between two shapes.

fn closest_points( &self, pos12: &Isometry<f32>, g1: &dyn Shape, g2: &dyn Shape, max_dist: f32, ) -> Result<ClosestPoints, Unsupported>

Computes the pair of closest points between two shapes.

fn cast_shapes( &self, pos12: &Isometry<f32>, vel12: &Vector<f32>, g1: &dyn Shape, g2: &dyn Shape, options: ShapeCastOptions, ) -> Result<Option<ShapeCastHit>, Unsupported>

Computes the smallest time when two shapes under translational movement are separated by a distance smaller or equal to distance.

fn cast_shapes_nonlinear( &self, motion1: &NonlinearRigidMotion, g1: &dyn Shape, motion2: &NonlinearRigidMotion, g2: &dyn Shape, start_time: f32, end_time: f32, stop_at_penetration: bool, ) -> Result<Option<ShapeCastHit>, Unsupported>

Computes the smallest time of impact of two shapes under translational and rotational movement.

fn chain<U: QueryDispatcher>(self, other: U) -> QueryDispatcherChain<Self, U>

where Self: Sized,

Construct a QueryDispatcher that falls back on other for cases not handled by self