Struct CollisionStart

pub struct CollisionStart {
    pub collider1: Entity,
    pub collider2: Entity,
    pub body1: Option<Entity>,
    pub body2: Option<Entity>,
}

A collision event that is triggered when two colliders start touching.

The event can be read using a MessageReader or observed using an observer. It is only triggered for entities with the CollisionEventsEnabled component.

Example

Below is an example of observing the CollisionStart event using an observer.

use avian2d::prelude::*;
use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct PressurePlate;

fn setup_pressure_plates(mut commands: Commands) {
    commands.spawn((
        PressurePlate,
        Collider::rectangle(1.0, 1.0),
        Sensor,
        // Enable collision events for this entity.
        CollisionEventsEnabled,
    ))
    .observe(on_player_stepped_on_plate);
}

fn on_player_stepped_on_plate(event: On<CollisionStart>, player_query: Query<&Player>) {
    // `colider1` and `body1` refer to the event target and its body.
    // `collider2` and `body2` refer to the other collider and its body.
    let pressure_plate = event.collider1;
    let other_entity = event.collider2;

    if player_query.contains(other_entity) {
        println!("Player {other_entity} stepped on pressure plate {pressure_plate}");
    }
}

The event can also be read as a Message using a MessageReader. This can be more efficient for processing large numbers of collisions.

fn print_started_collisions(mut collision_reader: MessageReader<CollisionStart>) {
    for event in collision_reader.read() {
        println!("{} and {} started colliding", event.collider1, event.collider2);
    }
}

Scheduling

The CollisionStart 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.

Fields

collider1: Entity

The entity of the collider that started colliding with collider2.

For observers watching this event as an EntityEvent, this is the target entity.

collider2: Entity

The entity of the collider that started colliding with collider1.

body1: Option<Entity>

The rigid body that collider1 is attached to.

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

body2: Option<Entity>

The rigid body that collider2 is attached to.

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

Trait Implementations

impl Clone for CollisionStart

fn clone(&self) -> CollisionStart

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CollisionStart

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

Formats the value using the given formatter.

impl EntityEvent for CollisionStart

where Self: Send + Sync + 'static,

fn event_target(&self) -> Entity

The Entity “target” of this EntityEvent. When triggered, this will run observers that watch for this specific entity.

fn event_target_mut(&mut self) -> &mut Entity

Returns a mutable reference to the Entity “target” of this EntityEvent. When triggered, this will run observers that watch for this specific entity.

impl Event for CollisionStart

where Self: Send + Sync + 'static,

type Trigger<'a> = EntityTrigger

Defines which observers will run, what data will be passed to them, and the order they will be run in. See Trigger for more info.

impl PartialEq for CollisionStart

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

impl Message for CollisionStart

where Self: Send + Sync + 'static,

impl StructuralPartialEq for CollisionStart