Struct bevy_xpbd_3d::components::Collider

pub struct Collider(_);

A collider used for collision detection.

By default, colliders generate collision events and cause a collision response for rigid bodies. If you only want collision events, you can add a Sensor component.

Creation

Collider has tons of methods for creating colliders of various shapes. For example, to add a ball collider to a rigid body, use Collider::ball:

use bevy::prelude::*;
use bevy_xpbd_3d::prelude::*;

fn setup(mut commands: Commands) {
    commands.spawn((RigidBody::Dynamic, Collider::ball(0.5)));
}

In addition, Bevy XPBD will automatically add some other components, like the following:

• ColliderAabb
• CollidingEntities
• ColliderMassProperties

Collision layers

You can use collsion layers to configure which entities can collide with each other.

See CollisionLayers for more information and examples.

Collision events

There are currently three different collision events: Collision, CollisionStarted and CollisionEnded. You can listen to these events as you normally would.

For example, you could read contacts like this:

use bevy::prelude::*;
use bevy_xpbd_3d::prelude::*;

fn my_system(mut collision_event_reader: EventReader<Collision>) {
    for Collision(contact) in collision_event_reader.iter() {
        println!("{:?} and {:?} are colliding", contact.entity1, contact.entity2);
    }
}

Advanced usage

Internally, Collider uses the shapes provided by parry. If you want to create a collider using these shapes, you can simply use Collider::from(SharedShape::some_method()).

To get a reference to the internal SharedShape, you can use the get_shape method.

Implementations

impl Collider

pub fn get_shape(&self) -> &SharedShape

Gets the raw shape of the collider. The shapes are provided by parry.

pub fn compute_aabb( &self, position: Vector, rotation: Quaternion ) -> ColliderAabb

Computes the Axis-Aligned Bounding Box of the collider.

pub fn compound( shapes: Vec<(impl Into<Position>, impl Into<Rotation>, impl Into<Collider>)> ) -> Self

Creates a collider with a compound shape defined by a given vector of colliders with a position and a rotation.

Especially for dynamic rigid bodies, compound shape colliders should be preferred over triangle meshes and polylines, because convex shapes typically provide more reliable results.

If you want to create a compound shape from a 3D triangle mesh or 2D polyline, consider using the Collider::convex_decomposition method.

pub fn ball(radius: Scalar) -> Self

Creates a collider with a ball shape defined by its radius.

pub fn cuboid(x_length: Scalar, y_length: Scalar, z_length: Scalar) -> Self

Creates a collider with a cuboid shape defined by its extents.

pub fn cylinder(height: Scalar, radius: Scalar) -> Self

Creates a collider with a cylinder shape defined by its height along the Y axis and its radius on the XZ plane.

pub fn cone(height: Scalar, radius: Scalar) -> Self

Creates a collider with a cone shape defined by its height along the Y axis and the radius of its base on the XZ plane.

pub fn capsule(height: Scalar, radius: Scalar) -> Self

Creates a collider with a capsule shape defined by its height along the Y axis and its radius.

pub fn capsule_endpoints(a: Vector, b: Vector, radius: Scalar) -> Self

Creates a collider with a capsule shape defined by its end points a and b and its radius.

pub fn halfspace(outward_normal: Vector) -> Self

Creates a collider with a half-space shape defined by the outward normal of its planar boundary.

pub fn segment(a: Vector, b: Vector) -> Self

Creates a collider with a segment shape defined by its endpoints a and b.

pub fn triangle(a: Vector, b: Vector, c: Vector) -> Self

Creates a collider with a triangle shape defined by its points a, b and c.

pub fn polyline(vertices: Vec<Vector>, indices: Option<Vec<[u32; 2]>>) -> Self

Creates a collider with a polyline shape defined by its vertices and optionally an index buffer.

pub fn trimesh(vertices: Vec<Vector>, indices: Vec<[u32; 3]>) -> Self

Creates a collider with a triangle mesh shape defined by its vertex and index buffers.

pub fn trimesh_from_bevy_mesh(mesh: &Mesh) -> Option<Self>

Creates a collider with a triangle mesh shape built from a given Bevy Mesh.

pub fn convex_decomposition_from_bevy_mesh(mesh: &Mesh) -> Option<Self>

Creates a collider with a compound shape obtained from the decomposition of a triangle mesh built from a given Bevy Mesh.

pub fn convex_decomposition( vertices: Vec<Vector>, indices: Vec<[u32; 3]> ) -> Self

Creates a collider shape with a compound shape obtained from the decomposition of a given trimesh defined by its vertex and index buffers.

pub fn convex_hull(points: Vec<Vector>) -> Option<Self>

Creates a collider with a convex polyhedron shape obtained after computing the convex hull of the given points.

pub fn heightfield(heights: Vec<Vec<Scalar>>, scale: Vector) -> Self

Creates a collider with a heightfield shape.

A 3D heightfield is a rectangle on the XZ plane, subdivided in a grid pattern at regular intervals.

heights is a matrix indicating the altitude of each subdivision point. The number of rows indicates the number of subdivisions along the X axis, while the number of columns indicates the number of subdivisions along the Z axis.

scale indicates the size of each rectangle on the XZ plane.

Methods from Deref<Target = SharedShape>

pub fn make_mut(&mut self) -> &mut (dyn Shape + 'static)

If this shape is shared, then the content of self is cloned into a unique instance, and a mutable reference to that instance is returned.

Trait Implementations

impl Clone for Collider

fn clone(&self) -> Collider

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Colliderwhere Self: Send + Sync + 'static,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either [TableStorage] or [SparseStorage].

impl Debug for Collider

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

Formats the value using the given formatter.

impl Default for Collider

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Collider

type Target = SharedShape

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Collider

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<SharedShape> for Collider

fn from(original: SharedShape) -> Collider

Converts to this type from the input type.