Struct Unsupported

pub struct Unsupported;

Error indicating that a geometric query is not supported between certain shape combinations.

Many geometric queries in Parry (like distance calculation, contact detection, or time-of-impact) are implemented using specialized algorithms for specific pairs of shapes. When you attempt a query between two shapes for which no implementation exists, this error is returned.

When This Error Occurs

This error typically occurs in two situations:

1. Missing Implementation: The query has not been implemented for the specific pair of shapes. For example, some advanced queries might not support all combinations of composite shapes.

2. Complex Shape Combinations: Certain queries involving composite shapes (like Compound, TriMesh, or HeightField) may not be fully supported, especially for less common operations.

Common Scenarios

• Computing contact manifolds between two custom shapes that don’t have a specialized implementation
• Using non-linear shape casting with certain composite shapes
• Querying distance between shapes that require more complex algorithms not yet implemented

How to Handle This Error

When you encounter this error, you have several options:

1. Use a Different Query Type

Try a more basic query that’s more widely supported:

// If contact manifolds are unsupported, try basic contact:
if let Ok(contact) = contact(&pos1, &shape1, &pos2, &shape2, 0.0) {
    // Process the contact point
}

// Or try distance computation:
let dist = distance(&pos1, &shape1, &pos2, &shape2);

2. Decompose Complex Shapes

Break down complex shapes into simpler components:

// Instead of querying against a complex mesh directly,
// iterate through its triangles:
for triangle in mesh.triangles() {
    let dist = distance(&pos1, &triangle, &pos2, &ball);
    // Process each triangle-ball pair
}

3. Use the BVH for Composite Shapes

For shapes with BVH acceleration structures (like TriMesh), use specialized traversal methods:

// Use BVH queries instead of direct shape queries:
for leaf_id in mesh.bvh().intersect_aabb(&query_aabb) {
    let triangle = mesh.triangle(leaf_id);
    // Process the triangle
}

4. Implement a Custom Query Dispatcher

For advanced use cases, implement the QueryDispatcher trait to add support for your specific shape combinations:

struct MyQueryDispatcher {
    default: DefaultQueryDispatcher,
}

// Implement QueryDispatcher and add your custom query implementations

Example: Catching and Handling the Error

let ball = Ball::new(1.0);
let cuboid = Cuboid::new(Vector3::new(1.0, 1.0, 1.0));
let pos1 = Isometry3::identity();
let pos2 = Isometry3::identity();

// Most queries return Result<T, Unsupported>
match contact(&pos1, &ball, &pos2, &cuboid, 0.0) {
    Ok(Some(contact)) => {
        // Query succeeded and found a contact
        println!("Contact found at distance: {}", contact.dist);
    }
    Ok(None) => {
        // Query succeeded but no contact found
        println!("No contact");
    }
    Err(Unsupported) => {
        // Query not supported for this shape combination
        println!("This query is not supported between these shapes");
        // Fall back to an alternative approach
    }
}

Trait Implementations

impl Clone for Unsupported

fn clone(&self) -> Unsupported

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Unsupported

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Unsupported

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Unsupported

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for Unsupported

fn eq(&self, other: &Unsupported) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Unsupported

impl Eq for Unsupported

impl StructuralPartialEq for Unsupported