Struct OnCollisionEnd

pub struct OnCollisionEnd {
    pub collider: Entity,
    pub body: Option<Entity>,
}

A collision event that is triggered for observers when two colliders stop touching.

The event is only triggered if the target entity has the CollisionEventsEnabled component.

Unlike CollisionEnded, this event can not be read using an EventReader. Instead, you must use an observer. This makes it good for entity-specific collision listeners.

Example

use avian3d::prelude::*;
use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct PressurePlate;

fn setup_pressure_plates(mut commands: Commands) {
    commands.spawn((
        PressurePlate,
        Collider::cuboid(1.0, 0.1, 1.0),
        Sensor,
        // Enable collision events for this entity.
        CollisionEventsEnabled,
    ))
    .observe(|trigger: Trigger<OnCollisionEnd>, player_query: Query<&Player>| {
        let pressure_plate = trigger.target();
        let other_entity = trigger.collider;
        if player_query.contains(other_entity) {
            println!("Player {other_entity} stepped off of pressure plate {pressure_plate}");
        }
    });
}

Scheduling

The OnCollisionEnd event is triggered after the physics step in the CollisionEventSystems system set. At this point, the solver has already run and contact impulses have been updated.

Note that if one of the colliders was removed or the bounding boxes of the colliders stopped overlapping, the ContactPair between the entities was also removed, and the contact data will not be available through Collisions.

Fields

collider: Entity

The entity of the collider that stopped colliding with the Trigger::target.

body: Option<Entity>

The entity of the rigid body that stopped colliding with the Trigger::target.

If the collider is not attached to a rigid body, this will be None.

Trait Implementations

impl Clone for OnCollisionEnd

fn clone(&self) -> OnCollisionEnd

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OnCollisionEnd

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

Formats the value using the given formatter.

impl Event for OnCollisionEnd

where Self: Send + Sync + 'static,

const AUTO_PROPAGATE: bool = false

When true, this event will always attempt to propagate when triggered, without requiring a call to Trigger::propagate.

type Traversal = ()

The component that describes which Entity to propagate this event to next, when propagation is enabled.

fn register_component_id(world: &mut World) -> ComponentId

Generates the ComponentId for this event type.

fn component_id(world: &World) -> Option<ComponentId>

Fetches the ComponentId for this event type, if it has already been generated.

impl PartialEq for OnCollisionEnd

fn eq(&self, other: &OnCollisionEnd) -> 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 OnCollisionEnd

impl StructuralPartialEq for OnCollisionEnd