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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
use crossbeam::channel::Receiver;
use rapier::dynamics::{
CCDSolver, ImpulseJointSet, IntegrationParameters, IslandManager, MultibodyJointSet,
RigidBodySet,
};
use rapier::geometry::{
ColliderSet, CollisionEvent, ContactForceEvent, DefaultBroadPhase, NarrowPhase,
};
use rapier::math::{Real, Vector};
use rapier::pipeline::{PhysicsHooks, PhysicsPipeline, QueryPipeline};
pub struct PhysicsSnapshot {
timestep_id: usize,
broad_phase: Vec<u8>,
narrow_phase: Vec<u8>,
bodies: Vec<u8>,
colliders: Vec<u8>,
impulse_joints: Vec<u8>,
multibody_joints: Vec<u8>,
island_manager: Vec<u8>,
}
pub struct DeserializedPhysicsSnapshot {
pub timestep_id: usize,
pub broad_phase: DefaultBroadPhase,
pub narrow_phase: NarrowPhase,
pub island_manager: IslandManager,
pub bodies: RigidBodySet,
pub colliders: ColliderSet,
pub impulse_joints: ImpulseJointSet,
pub multibody_joints: MultibodyJointSet,
}
impl PhysicsSnapshot {
pub fn new(
timestep_id: usize,
broad_phase: &DefaultBroadPhase,
narrow_phase: &NarrowPhase,
island_manager: &IslandManager,
bodies: &RigidBodySet,
colliders: &ColliderSet,
impulse_joints: &ImpulseJointSet,
multibody_joints: &MultibodyJointSet,
) -> bincode::Result<Self> {
Ok(Self {
timestep_id,
broad_phase: bincode::serialize(broad_phase)?,
narrow_phase: bincode::serialize(narrow_phase)?,
island_manager: bincode::serialize(island_manager)?,
bodies: bincode::serialize(bodies)?,
colliders: bincode::serialize(colliders)?,
impulse_joints: bincode::serialize(impulse_joints)?,
multibody_joints: bincode::serialize(multibody_joints)?,
})
}
pub fn restore(&self) -> bincode::Result<DeserializedPhysicsSnapshot> {
Ok(DeserializedPhysicsSnapshot {
timestep_id: self.timestep_id,
broad_phase: bincode::deserialize(&self.broad_phase)?,
narrow_phase: bincode::deserialize(&self.narrow_phase)?,
island_manager: bincode::deserialize(&self.island_manager)?,
bodies: bincode::deserialize(&self.bodies)?,
colliders: bincode::deserialize(&self.colliders)?,
impulse_joints: bincode::deserialize(&self.impulse_joints)?,
multibody_joints: bincode::deserialize(&self.multibody_joints)?,
})
}
pub fn print_snapshot_len(&self) {
let total = self.broad_phase.len()
+ self.narrow_phase.len()
+ self.island_manager.len()
+ self.bodies.len()
+ self.colliders.len()
+ self.impulse_joints.len()
+ self.multibody_joints.len();
println!("Snapshot length: {}B", total);
println!("|_ broad_phase: {}B", self.broad_phase.len());
println!("|_ narrow_phase: {}B", self.narrow_phase.len());
println!("|_ island_manager: {}B", self.island_manager.len());
println!("|_ bodies: {}B", self.bodies.len());
println!("|_ colliders: {}B", self.colliders.len());
println!("|_ impulse_joints: {}B", self.impulse_joints.len());
println!("|_ multibody_joints: {}B", self.multibody_joints.len());
}
}
pub struct PhysicsState {
pub islands: IslandManager,
pub broad_phase: DefaultBroadPhase,
pub narrow_phase: NarrowPhase,
pub bodies: RigidBodySet,
pub colliders: ColliderSet,
pub impulse_joints: ImpulseJointSet,
pub multibody_joints: MultibodyJointSet,
pub ccd_solver: CCDSolver,
pub pipeline: PhysicsPipeline,
pub query_pipeline: QueryPipeline,
pub integration_parameters: IntegrationParameters,
pub gravity: Vector<Real>,
pub hooks: Box<dyn PhysicsHooks>,
}
impl Default for PhysicsState {
fn default() -> Self {
Self::new()
}
}
impl PhysicsState {
pub fn new() -> Self {
Self {
islands: IslandManager::new(),
broad_phase: DefaultBroadPhase::new(),
narrow_phase: NarrowPhase::new(),
bodies: RigidBodySet::new(),
colliders: ColliderSet::new(),
impulse_joints: ImpulseJointSet::new(),
multibody_joints: MultibodyJointSet::new(),
ccd_solver: CCDSolver::new(),
pipeline: PhysicsPipeline::new(),
query_pipeline: QueryPipeline::new(),
integration_parameters: IntegrationParameters::default(),
gravity: Vector::y() * -9.81,
hooks: Box::new(()),
}
}
}
pub struct PhysicsEvents {
pub collision_events: Receiver<CollisionEvent>,
pub contact_force_events: Receiver<ContactForceEvent>,
}
impl PhysicsEvents {
pub fn poll_all(&self) {
while self.collision_events.try_recv().is_ok() {}
while self.contact_force_events.try_recv().is_ok() {}
}
}
|
