Struct RoundShape

Source

#[repr(C)]pub struct RoundShape<S> {
    pub inner_shape: S,
    pub border_radius: f32,
}

Expand description

A shape with rounded borders.

§What is a Rounded Shape?

A RoundShape wraps an existing shape and adds a “border radius” around it. This creates a smooth, rounded version of the original shape by effectively expanding it outward by the border radius distance. Think of it as adding padding or a cushion around the shape.

The rounding is achieved by using Minkowski sum operations: any point on the surface of the rounded shape is computed by taking a point on the original shape’s surface and moving it outward along the surface normal by the border radius distance.

§Common Use Cases

Creating softer collisions: Rounded shapes can make collision detection more forgiving and realistic, as sharp corners and edges are smoothed out.
Capsule-like shapes: You can create capsule variations of any shape by adding a border radius (e.g., a rounded cuboid becomes similar to a capsule).
Visual aesthetics: Rounded shapes often look more pleasing and natural than sharp-edged shapes.
Improved numerical stability: Rounded shapes can sometimes be more numerically stable in collision detection algorithms since they avoid sharp corners.

§Examples

§Creating a Rounded Cuboid

use parry3d::shape::{RoundShape, Cuboid};
use parry3d_f64::shape::{RoundShape, Cuboid};
use nalgebra::Vector3;

// Create a cuboid with half-extents of 1.0 in each direction
let cuboid = Cuboid::new(Vector3::new(1.0, 1.0, 1.0));

// Add a border radius of 0.2 to create a rounded cuboid
let rounded_cuboid = RoundShape {
    inner_shape: cuboid,
    border_radius: 0.2,
};

// The effective size is now 1.2 in each direction from the center
// (1.0 from the cuboid + 0.2 from the border)
assert_eq!(rounded_cuboid.inner_shape.half_extents.x, 1.0);
assert_eq!(rounded_cuboid.border_radius, 0.2);

§Creating a Rounded Triangle (2D)

use parry2d::shape::{RoundShape, Triangle};
use parry2d_f64::shape::{RoundShape, Triangle};
use nalgebra::Point2;

// Create a triangle
let triangle = Triangle::new(
    Point2::origin(),
    Point2::new(1.0, 0.0),
    Point2::new(0.0, 1.0),
);

// Add rounding with a 0.1 border radius
let rounded_triangle = RoundShape {
    inner_shape: triangle,
    border_radius: 0.1,
};

// The rounded triangle will have smooth, curved edges instead of sharp corners
assert_eq!(rounded_triangle.border_radius, 0.1);

§Comparing Support Points

This example shows how the border radius affects the support point calculation:

use parry3d::shape::{RoundShape, Cuboid, SupportMap};
use parry3d_f64::shape::{RoundShape, Cuboid, SupportMap};
use nalgebra::Vector3;

let cuboid = Cuboid::new(Vector3::new(1.0, 1.0, 1.0));
let rounded_cuboid = RoundShape {
    inner_shape: cuboid,
    border_radius: 0.5,
};

// Query the support point in the direction (1, 1, 1)
let direction = Vector3::new(1.0, 1.0, 1.0);
let support_point = rounded_cuboid.local_support_point(&direction);

// The support point will be further out than the original cuboid's support point
// due to the border radius
let cuboid_support = cuboid.local_support_point(&direction);

// The rounded shape extends further in all directions
assert!(support_point.x > cuboid_support.x);
assert!(support_point.y > cuboid_support.y);
assert!(support_point.z > cuboid_support.z);

§Using with Different Shape Types

RoundShape can wrap any shape that implements the SupportMap trait:

use parry3d::shape::{RoundShape, Ball, Segment, SupportMap};
use parry3d_f64::shape::{RoundShape, Ball, Segment, SupportMap};
use nalgebra::{Point3, Vector3};

// Rounded ball (creates a slightly larger sphere)
let ball = Ball::new(1.0);
let rounded_ball = RoundShape {
    inner_shape: ball,
    border_radius: 0.1,
};
// Effective radius is now 1.1

// Rounded segment (creates a capsule)
let segment = Segment::new(
    Point3::origin(),
    Point3::new(0.0, 2.0, 0.0),
);
let rounded_segment = RoundShape {
    inner_shape: segment,
    border_radius: 0.5,
};
// This creates a capsule with radius 0.5

§Performance Considerations

The computational cost of queries on a RoundShape is essentially the same as for the inner shape, plus a small constant overhead to apply the border radius.
RoundShape is most efficient when used with shapes that already implement SupportMap efficiently (like primitives: Ball, Cuboid, Capsule, etc.).
The struct is Copy when the inner shape is Copy, making it efficient to pass around.

§Technical Details

The RoundShape implements the SupportMap trait by computing the support point of the inner shape and then offsetting it by the border radius in the query direction. This is mathematically equivalent to computing the Minkowski sum of the inner shape with a ball of radius equal to the border radius.

Fields§

§inner_shape: S

The shape being rounded.

This is the original, “inner” shape before the border radius is applied. The rounded shape’s surface will be at a distance of border_radius from this inner shape’s surface.

§border_radius: f32

The radius of the rounded border.

This value determines how much the shape is expanded outward. A larger border radius creates a more “padded” shape. Must be non-negative (typically positive).

For example, if border_radius is 0.5, every point on the original shape’s surface will be moved 0.5 units outward along its surface normal.

Struct RoundShapeCopy item path

§What is a Rounded Shape?

§Common Use Cases

§Examples

§Creating a Rounded Cuboid

§Creating a Rounded Triangle (2D)

§Comparing Support Points

§Using with Different Shape Types

§Performance Considerations

§Technical Details

Fields§

Implementations§

impl RoundShape<Cone>

pub fn to_outline( &self, nsubdiv: u32, border_nsubdiv: u32, ) -> (Vec<Point3<f32>>, Vec<[u32; 2]>)

impl RoundShape<ConvexPolyhedron>

pub fn to_outline(&self, nsubdivs: u32) -> (Vec<Point3<f32>>, Vec<[u32; 2]>)

impl RoundShape<Cuboid>

pub fn to_outline(&self, nsubdivs: u32) -> (Vec<Point<f32>>, Vec<[u32; 2]>)

impl RoundShape<Cylinder>

pub fn to_outline( &self, nsubdiv: u32, border_nsubdiv: u32, ) -> (Vec<Point3<f32>>, Vec<[u32; 2]>)

Trait Implementations§

impl<S: Clone> Clone for RoundShape<S>

fn clone(&self) -> RoundShape<S>

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

impl<S: Debug> Debug for RoundShape<S>

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

impl<S: SupportMap> PointQuery for RoundShape<S>

fn project_local_point( &self, point: &Point<f32>, solid: bool, ) -> PointProjection

fn project_local_point_and_get_feature( &self, point: &Point<f32>, ) -> (PointProjection, FeatureId)

fn project_local_point_with_max_dist( &self, pt: &Point<f32>, solid: bool, max_dist: f32, ) -> Option<PointProjection>

fn project_point_with_max_dist( &self, m: &Isometry<f32>, pt: &Point<f32>, solid: bool, max_dist: f32, ) -> Option<PointProjection>

fn distance_to_local_point(&self, pt: &Point<f32>, solid: bool) -> f32

fn contains_local_point(&self, pt: &Point<f32>) -> bool

fn project_point( &self, m: &Isometry<f32>, pt: &Point<f32>, solid: bool, ) -> PointProjection

fn distance_to_point( &self, m: &Isometry<f32>, pt: &Point<f32>, solid: bool, ) -> f32

fn project_point_and_get_feature( &self, m: &Isometry<f32>, pt: &Point<f32>, ) -> (PointProjection, FeatureId)

fn contains_point(&self, m: &Isometry<f32>, pt: &Point<f32>) -> bool

impl<S: SupportMap> RayCast for RoundShape<S>

fn cast_local_ray_and_get_normal( &self, ray: &Ray, max_time_of_impact: f32, solid: bool, ) -> Option<RayIntersection>

fn cast_local_ray( &self, ray: &Ray, max_time_of_impact: f32, solid: bool, ) -> Option<f32>

fn intersects_local_ray(&self, ray: &Ray, max_time_of_impact: f32) -> bool

fn cast_ray( &self, m: &Isometry<f32>, ray: &Ray, max_time_of_impact: f32, solid: bool, ) -> Option<f32>

fn cast_ray_and_get_normal( &self, m: &Isometry<f32>, ray: &Ray, max_time_of_impact: f32, solid: bool, ) -> Option<RayIntersection>

fn intersects_ray( &self, m: &Isometry<f32>, ray: &Ray, max_time_of_impact: f32, ) -> bool

impl Shape for RoundShape<Cone>

fn clone_dyn(&self) -> Box<dyn Shape>

fn scale_dyn( &self, scale: &Vector<f32>, num_subdivisions: u32, ) -> Option<Box<dyn Shape>>

fn compute_local_aabb(&self) -> Aabb

fn compute_local_bounding_sphere(&self) -> BoundingSphere

fn compute_aabb(&self, position: &Isometry<f32>) -> Aabb

fn mass_properties(&self, density: f32) -> MassProperties

fn is_convex(&self) -> bool

fn shape_type(&self) -> ShapeType

fn as_typed_shape(&self) -> TypedShape<'_>

fn ccd_thickness(&self) -> f32

fn ccd_angular_thickness(&self) -> f32

fn as_support_map(&self) -> Option<&dyn SupportMap>

fn as_polygonal_feature_map(&self) -> Option<(&dyn PolygonalFeatureMap, f32)>

fn clone_box(&self) -> Box<dyn Shape>

fn compute_bounding_sphere(&self, position: &Isometry<f32>) -> BoundingSphere

fn as_composite_shape(&self) -> Option<&dyn CompositeShape>

fn feature_normal_at_point( &self, _feature: FeatureId, _point: &Point<f32>, ) -> Option<Unit<Vector<f32>>>

fn compute_swept_aabb( &self, start_pos: &Isometry<f32>, end_pos: &Isometry<f32>, ) -> Aabb

impl Shape for RoundShape<ConvexPolyhedron>