nightshade 0.8.0

A cross-platform data-oriented game engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use freecs::Entity;
use rapier3d::prelude::*;
use std::sync::Mutex;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CollisionEventKind {
    Started,
    Stopped,
}

#[derive(Debug, Clone, Copy)]
pub struct CollisionEvent {
    pub entity_a: Entity,
    pub entity_b: Entity,
    pub kind: CollisionEventKind,
    pub is_sensor: bool,
}

#[derive(Debug, Clone, Copy)]
pub struct ContactForceEvent {
    pub entity_a: Entity,
    pub entity_b: Entity,
    pub total_force_magnitude: f32,
}

pub(crate) struct RawCollisionEvent {
    pub collider_a: ColliderHandle,
    pub collider_b: ColliderHandle,
    pub started: bool,
    pub is_sensor: bool,
}

pub(crate) struct RawContactForceEvent {
    pub collider_a: ColliderHandle,
    pub collider_b: ColliderHandle,
    pub total_force_magnitude: f32,
}

pub(crate) struct CollisionEventCollector {
    pub raw_collisions: Mutex<Vec<RawCollisionEvent>>,
    pub raw_contact_forces: Mutex<Vec<RawContactForceEvent>>,
}

impl CollisionEventCollector {
    pub fn new() -> Self {
        Self {
            raw_collisions: Mutex::new(Vec::new()),
            raw_contact_forces: Mutex::new(Vec::new()),
        }
    }

    pub fn drain_raw_collisions(&self) -> Vec<RawCollisionEvent> {
        let mut lock = self.raw_collisions.lock().unwrap();
        std::mem::take(&mut *lock)
    }

    pub fn drain_raw_contact_forces(&self) -> Vec<RawContactForceEvent> {
        let mut lock = self.raw_contact_forces.lock().unwrap();
        std::mem::take(&mut *lock)
    }
}

impl EventHandler for CollisionEventCollector {
    fn handle_collision_event(
        &self,
        _bodies: &RigidBodySet,
        _colliders: &ColliderSet,
        event: rapier3d::geometry::CollisionEvent,
        _contact_pair: Option<&ContactPair>,
    ) {
        let (collider_a, collider_b, started, is_sensor) = match event {
            rapier3d::geometry::CollisionEvent::Started(a, b, flags) => {
                (a, b, true, flags.contains(CollisionEventFlags::SENSOR))
            }
            rapier3d::geometry::CollisionEvent::Stopped(a, b, flags) => {
                (a, b, false, flags.contains(CollisionEventFlags::SENSOR))
            }
        };
        let mut lock = self.raw_collisions.lock().unwrap();
        lock.push(RawCollisionEvent {
            collider_a,
            collider_b,
            started,
            is_sensor,
        });
    }

    fn handle_contact_force_event(
        &self,
        _dt: Real,
        _bodies: &RigidBodySet,
        _colliders: &ColliderSet,
        contact_pair: &ContactPair,
        total_force_magnitude: Real,
    ) {
        let mut lock = self.raw_contact_forces.lock().unwrap();
        lock.push(RawContactForceEvent {
            collider_a: contact_pair.collider1,
            collider_b: contact_pair.collider2,
            total_force_magnitude,
        });
    }
}