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
|
use crossbeam::channel::Receiver;
use rapier::dynamics::{
CCDSolver, ImpulseJointSet, IntegrationParameters, IslandManager, MultibodyJointSet,
RigidBodySet,
};
use rapier::geometry::{BroadPhase, ColliderSet, CollisionEvent, ContactForceEvent, NarrowPhase};
use rapier::math::{Real, Vector};
use rapier::pipeline::{FractureEvent, 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>,
}
impl PhysicsSnapshot {
pub fn new(
timestep_id: usize,
broad_phase: &BroadPhase,
narrow_phase: &NarrowPhase,
bodies: &RigidBodySet,
colliders: &ColliderSet,
impulse_joints: &ImpulseJointSet,
) -> bincode::Result<Self> {
Ok(Self {
timestep_id,
broad_phase: bincode::serialize(broad_phase)?,
narrow_phase: bincode::serialize(narrow_phase)?,
bodies: bincode::serialize(bodies)?,
colliders: bincode::serialize(colliders)?,
impulse_joints: bincode::serialize(impulse_joints)?,
})
}
pub fn restore(
&self,
) -> bincode::Result<(
usize,
BroadPhase,
NarrowPhase,
RigidBodySet,
ColliderSet,
ImpulseJointSet,
)> {
Ok((
self.timestep_id,
bincode::deserialize(&self.broad_phase)?,
bincode::deserialize(&self.narrow_phase)?,
bincode::deserialize(&self.bodies)?,
bincode::deserialize(&self.colliders)?,
bincode::deserialize(&self.impulse_joints)?,
))
}
pub fn print_snapshot_len(&self) {
let total = self.broad_phase.len()
+ self.narrow_phase.len()
+ self.bodies.len()
+ self.colliders.len()
+ self.impulse_joints.len();
println!("Snapshot length: {}B", total);
println!("|_ broad_phase: {}B", self.broad_phase.len());
println!("|_ narrow_phase: {}B", self.narrow_phase.len());
println!("|_ bodies: {}B", self.bodies.len());
println!("|_ colliders: {}B", self.colliders.len());
println!("|_ impulse_joints: {}B", self.impulse_joints.len());
}
}
pub struct PhysicsState {
pub islands: IslandManager,
pub broad_phase: BroadPhase,
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 PhysicsState {
pub fn new() -> Self {
Self {
islands: IslandManager::new(),
broad_phase: BroadPhase::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>,
pub fracture_events: Receiver<FractureEvent>,
}
impl PhysicsEvents {
pub fn poll_all(&self) {
while let Ok(_) = self.collision_events.try_recv() {}
while let Ok(_) = self.contact_force_events.try_recv() {}
while let Ok(_) = self.fracture_events.try_recv() {}
}
}
|
