aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/dynamics/ccd/ccd_solver.rs8
-rw-r--r--src/geometry/mod.rs60
-rw-r--r--src/geometry/narrow_phase.rs24
-rw-r--r--src/pipeline/event_handler.rs44
4 files changed, 67 insertions, 69 deletions
diff --git a/src/dynamics/ccd/ccd_solver.rs b/src/dynamics/ccd/ccd_solver.rs
index d15b28c..a4b1419 100644
--- a/src/dynamics/ccd/ccd_solver.rs
+++ b/src/dynamics/ccd/ccd_solver.rs
@@ -5,7 +5,7 @@ use crate::dynamics::{
RigidBodyCcd, RigidBodyHandle, RigidBodyMassProps, RigidBodyPosition, RigidBodyVelocity,
};
use crate::geometry::{
- ColliderParent, ColliderPosition, ColliderShape, ColliderType, IntersectionEvent, NarrowPhase,
+ ColliderParent, ColliderPosition, ColliderShape, ColliderType, CollisionEvent, NarrowPhase,
};
use crate::math::Real;
use crate::parry::utils::SortedPair;
@@ -613,11 +613,11 @@ impl CCDSolver {
if !intersect_before
&& !intersect_after
&& (co_flags1.active_events | co_flags2.active_events)
- .contains(ActiveEvents::INTERSECTION_EVENTS)
+ .contains(ActiveEvents::COLLISION_EVENTS)
{
// Emit one intersection-started and one intersection-stopped event.
- events.handle_intersection_event(IntersectionEvent::new(toi.c1, toi.c2, true));
- events.handle_intersection_event(IntersectionEvent::new(toi.c1, toi.c2, false));
+ events.handle_intersection_event(CollisionEvent::Started(toi.c1, toi.c2));
+ events.handle_intersection_event(CollisionEvent::Stopped(toi.c1, toi.c2));
}
}
diff --git a/src/geometry/mod.rs b/src/geometry/mod.rs
index 0462cbf..83c687b 100644
--- a/src/geometry/mod.rs
+++ b/src/geometry/mod.rs
@@ -52,38 +52,44 @@ pub type TOI = parry::query::TOI;
pub use parry::shape::SharedShape;
#[derive(Copy, Clone, Hash, Debug)]
-/// Events occurring when two collision objects start or stop being in contact (or penetration).
-pub enum ContactEvent {
- /// Event occurring when two collision objects start being in contact.
- ///
- /// This event is generated whenever the narrow-phase finds a contact between two collision objects that did not have any contact at the last update.
+/// Events occurring when two colliders start or stop being in contact (or intersecting)
+pub enum CollisionEvent {
+ /// Event occurring when two colliders start being in contact (or intersecting)
Started(ColliderHandle, ColliderHandle),
- /// Event occurring when two collision objects stop being in contact.
- ///
- /// This event is generated whenever the narrow-phase fails to find any contact between two collision objects that did have at least one contact at the last update.
+ /// Event occurring when two colliders stop being in contact (or intersecting)
Stopped(ColliderHandle, ColliderHandle),
}
-#[derive(Copy, Clone, Debug)]
-/// Events occurring when two collision objects start or stop being in close proximity, contact, or disjoint.
-pub struct IntersectionEvent {
- /// The first collider to which the proximity event applies.
- pub collider1: ColliderHandle,
- /// The second collider to which the proximity event applies.
- pub collider2: ColliderHandle,
- /// Are the two colliders intersecting?
- pub intersecting: bool,
-}
+impl CollisionEvent {
+ pub(crate) fn new(h1: ColliderHandle, h2: ColliderHandle, start: bool) -> Self {
+ if start {
+ Self::Started(h1, h2)
+ } else {
+ Self::Stopped(h1, h2)
+ }
+ }
+
+ /// Is this a `Started` collision event?
+ pub fn started(self) -> bool {
+ matches!(self, CollisionEvent::Started(_, _))
+ }
+
+ /// Is this a `Stopped` collision event?
+ pub fn stopped(self) -> bool {
+ matches!(self, CollisionEvent::Stopped(_, _))
+ }
+
+ /// The handle of the first collider involved in this collision event.
+ pub fn collider1(self) -> ColliderHandle {
+ match self {
+ Self::Started(h, _) | Self::Stopped(h, _) => h,
+ }
+ }
-impl IntersectionEvent {
- /// Instantiates a new proximity event.
- ///
- /// Panics if `prev_status` is equal to `new_status`.
- pub fn new(collider1: ColliderHandle, collider2: ColliderHandle, intersecting: bool) -> Self {
- Self {
- collider1,
- collider2,
- intersecting,
+ /// The handle of the second collider involved in this collision event.
+ pub fn collider2(self) -> ColliderHandle {
+ match self {
+ Self::Started(_, h) | Self::Stopped(_, h) => h,
}
}
}
diff --git a/src/geometry/narrow_phase.rs b/src/geometry/narrow_phase.rs
index cf78b81..8a57ef4 100644
--- a/src/geometry/narrow_phase.rs
+++ b/src/geometry/narrow_phase.rs
@@ -8,9 +8,9 @@ use crate::dynamics::{
};
use crate::geometry::{
BroadPhasePairEvent, ColliderChanges, ColliderGraphIndex, ColliderHandle, ColliderMaterial,
- ColliderPair, ColliderParent, ColliderPosition, ColliderShape, ColliderType, ContactData,
- ContactEvent, ContactManifold, ContactManifoldData, ContactPair, InteractionGraph,
- IntersectionEvent, SolverContact, SolverFlags,
+ ColliderPair, ColliderParent, ColliderPosition, ColliderShape, ColliderType, CollisionEvent,
+ ContactData, ContactManifold, ContactManifoldData, ContactPair, InteractionGraph,
+ SolverContact, SolverFlags,
};
use crate::math::{Real, Vector};
use crate::pipeline::{
@@ -516,10 +516,10 @@ impl NarrowPhase {
let co_flag2: &ColliderFlags = colliders.index(pair.collider2.0);
if (co_flag1.active_events | co_flag2.active_events)
- .contains(ActiveEvents::INTERSECTION_EVENTS)
+ .contains(ActiveEvents::COLLISION_EVENTS)
{
let prox_event =
- IntersectionEvent::new(pair.collider1, pair.collider2, false);
+ CollisionEvent::Stopped(pair.collider1, pair.collider2);
events.handle_intersection_event(prox_event)
}
}
@@ -551,10 +551,10 @@ impl NarrowPhase {
let co_flag2: &ColliderFlags = colliders.index(pair.collider2.0);
if (co_flag1.active_events | co_flag2.active_events)
- .contains(ActiveEvents::CONTACT_EVENTS)
+ .contains(ActiveEvents::COLLISION_EVENTS)
{
events.handle_contact_event(
- ContactEvent::Stopped(pair.collider1, pair.collider2),
+ CollisionEvent::Stopped(pair.collider1, pair.collider2),
&ctct,
)
}
@@ -795,10 +795,10 @@ impl NarrowPhase {
let co_flags2: &ColliderFlags = colliders.index(handle2.0);
let active_events = co_flags1.active_events | co_flags2.active_events;
- if active_events.contains(ActiveEvents::INTERSECTION_EVENTS)
+ if active_events.contains(ActiveEvents::COLLISION_EVENTS)
&& had_intersection != edge.weight
{
- events.handle_intersection_event(IntersectionEvent::new(
+ events.handle_intersection_event(CollisionEvent::new(
handle1,
handle2,
edge.weight,
@@ -1027,15 +1027,15 @@ impl NarrowPhase {
let active_events = co_flags1.active_events | co_flags2.active_events;
if pair.has_any_active_contact != had_any_active_contact {
- if active_events.contains(ActiveEvents::CONTACT_EVENTS) {
+ if active_events.contains(ActiveEvents::COLLISION_EVENTS) {
if pair.has_any_active_contact {
events.handle_contact_event(
- ContactEvent::Started(pair.collider1, pair.collider2),
+ CollisionEvent::Started(pair.collider1, pair.collider2),
pair,
);
} else {
events.handle_contact_event(
- ContactEvent::Stopped(pair.collider1, pair.collider2),
+ CollisionEvent::Stopped(pair.collider1, pair.collider2),
pair,
);
}
diff --git a/src/pipeline/event_handler.rs b/src/pipeline/event_handler.rs
index c54acc2..5fa90c6 100644
--- a/src/pipeline/event_handler.rs
+++ b/src/pipeline/event_handler.rs
@@ -1,14 +1,13 @@
-use crate::geometry::{ContactEvent, ContactPair, IntersectionEvent};
+use crate::geometry::{CollisionEvent, ContactPair};
use crossbeam::channel::Sender;
bitflags::bitflags! {
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
/// Flags affecting the events generated for this collider.
pub struct ActiveEvents: u32 {
- /// If set, Rapier will call `EventHandler::handle_intersection_event` whenever relevant for this collider.
- const INTERSECTION_EVENTS = 0b0001;
- /// If set, Rapier will call `PhysicsHooks::handle_contact_event` whenever relevant for this collider.
- const CONTACT_EVENTS = 0b0010;
+ /// If set, Rapier will call `EventHandler::handle_intersection_event` and
+ /// `EventHandler::handle_contact_event` whenever relevant for this collider.
+ const COLLISION_EVENTS = 0b0001;
}
}
@@ -22,47 +21,40 @@ impl Default for ActiveEvents {
///
/// Implementors of this trait will typically collect these events for future processing.
pub trait EventHandler: Send + Sync {
- /// Handle an intersection event.
+ /// Handle a collision event.
///
/// A intersection event is emitted when the state of intersection between two colliders changes.
- fn handle_intersection_event(&self, event: IntersectionEvent);
+ fn handle_intersection_event(&self, event: CollisionEvent);
/// Handle a contact event.
///
/// A contact event is emitted when two collider start or stop touching, independently from the
/// number of contact points involved.
- fn handle_contact_event(&self, event: ContactEvent, contact_pair: &ContactPair);
+ fn handle_contact_event(&self, event: CollisionEvent, contact_pair: &ContactPair);
}
impl EventHandler for () {
- fn handle_intersection_event(&self, _event: IntersectionEvent) {}
- fn handle_contact_event(&self, _event: ContactEvent, _contact_pair: &ContactPair) {}
+ fn handle_intersection_event(&self, _event: CollisionEvent) {}
+ fn handle_contact_event(&self, _event: CollisionEvent, _contact_pair: &ContactPair) {}
}
-/// A physics event handler that collects events into a crossbeam channel.
+/// A collision event handler that collects events into a crossbeam channel.
pub struct ChannelEventCollector {
- intersection_event_sender: Sender<IntersectionEvent>,
- contact_event_sender: Sender<ContactEvent>,
+ event_sender: Sender<CollisionEvent>,
}
impl ChannelEventCollector {
- /// Initialize a new physics event handler from crossbeam channel senders.
- pub fn new(
- intersection_event_sender: Sender<IntersectionEvent>,
- contact_event_sender: Sender<ContactEvent>,
- ) -> Self {
- Self {
- intersection_event_sender,
- contact_event_sender,
- }
+ /// Initialize a new collision event handler from crossbeam channel senders.
+ pub fn new(event_sender: Sender<CollisionEvent>) -> Self {
+ Self { event_sender }
}
}
impl EventHandler for ChannelEventCollector {
- fn handle_intersection_event(&self, event: IntersectionEvent) {
- let _ = self.intersection_event_sender.send(event);
+ fn handle_intersection_event(&self, event: CollisionEvent) {
+ let _ = self.event_sender.send(event);
}
- fn handle_contact_event(&self, event: ContactEvent, _: &ContactPair) {
- let _ = self.contact_event_sender.send(event);
+ fn handle_contact_event(&self, event: CollisionEvent, _: &ContactPair) {
+ let _ = self.event_sender.send(event);
}
}
generated by cgit (git 2.34.1) at 2026-02-03 08:43:17 +0000