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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
pub mod debug_render;
use fxhash::FxHashMap;
use glam::Vec2;
use rapier2d::{
dynamics::IntegrationParameters,
geometry,
glamx::vec2,
pipeline::{DebugRenderPipeline, PhysicsWorld},
prelude,
};
use crate::{
config::{CELLS_TO_METRES, CHUNK_SIZE, PHYSICS_DELTA_TIME},
sim::{
cell_manager::chunk::Chunk,
lib::marching_squares::{Marchable, marching_squares_vertex_trace},
rb_manager::debug_render::{DebugLineBuffer, DebugVertex},
},
};
pub use rapier2d::pipeline::DebugRenderMode;
pub struct PhysicsManager {
pub world: PhysicsWorld,
pub debug_render_pipeline: DebugRenderPipeline,
}
impl PhysicsManager {
pub fn new() -> Self {
let mut world = PhysicsWorld::new();
let gravity = vec2(0.0, 9.81 * CELLS_TO_METRES);
world.gravity = gravity;
world.integration_parameters = IntegrationParameters {
// 20 pixels <-> 1 meter
length_unit: CELLS_TO_METRES,
dt: PHYSICS_DELTA_TIME,
..prelude::IntegrationParameters::default()
};
PhysicsManager {
world,
debug_render_pipeline: prelude::DebugRenderPipeline::new(
prelude::DebugRenderStyle {
sleep_color_multiplier: [1.0; 4],
sleep_eligible_color_multiplier: [1.0; 4],
..prelude::DebugRenderStyle::default()
},
prelude::DebugRenderMode::default(),
),
}
}
}
// TODO remove
pub struct RbManager {
// move to sim manager
chunk_colliders: FxHashMap<(i32, i32), geometry::ColliderHandle>,
// move to sim manager
pub physics_manager: PhysicsManager,
debug_line_buffer: DebugLineBuffer,
}
impl RbManager {
pub fn tick(&mut self, _delta_time: f32) {
self.physics_manager.world.step();
}
pub fn debug_render(&mut self, mode: DebugRenderMode) -> &[DebugVertex] {
puffin::profile_function!();
self.debug_line_buffer.vertices.clear();
self.physics_manager.debug_render_pipeline.mode = mode;
self.physics_manager.world.debug_render(
&mut self.physics_manager.debug_render_pipeline,
&mut self.debug_line_buffer,
);
&self.debug_line_buffer.vertices
}
fn polyline_from_marchable(
marchable: &impl Marchable,
minimum_verts_per_poly: Option<u32>,
) -> (Vec<Vec2>, Vec<[u32; 2]>) {
let polys = marching_squares_vertex_trace(marchable);
let mut vertices = Vec::new();
let mut indices = Vec::new();
let minimum_verts = minimum_verts_per_poly.unwrap_or(3);
let centre_offset = (marchable.size() / 2).as_vec2() - 0.5;
for poly in polys {
let v = vertices.len() as u32;
let p = poly.len() as u32;
if p < minimum_verts {
continue;
}
for i in 0..p {
vertices.push(poly[i as usize] - centre_offset);
indices.push([v + i, v + (i + 1) % p]);
}
}
(vertices, indices)
}
fn polyline_collider_from_marchable(
marchable: &impl Marchable,
minimum_verts: Option<u32>,
) -> geometry::ColliderBuilder {
let (vertices, indices) = RbManager::polyline_from_marchable(marchable, minimum_verts);
geometry::ColliderBuilder::polyline(vertices, Some(indices))
}
pub fn convex_hull_collider_from_marchable(
marchable: &impl Marchable,
minimum_verts_per_poly: Option<u32>,
) -> geometry::ColliderBuilder {
puffin::profile_function!();
let (vertices, indices) =
RbManager::polyline_from_marchable(marchable, minimum_verts_per_poly);
// convex_decomposition will panic if we have fewer verts
if vertices.len() < 3 {
panic!("Too few vertices to build collider!");
} else {
puffin::profile_scope!("Convex decomposition");
// TODO there are some pathological cases here that are taking 5ms+
geometry::ColliderBuilder::convex_decomposition(&vertices, &indices)
}
}
pub fn upsert_chunk_collider(&mut self, cx: i32, cy: i32, chunk: &Chunk) {
puffin::profile_function!();
let collider =
RbManager::polyline_collider_from_marchable(chunk, Some(20)).translation(vec2(
(cx as f32 + 0.5) * CHUNK_SIZE as f32,
(cy as f32 + 0.5) * CHUNK_SIZE as f32,
));
if let Some(handle) = self.chunk_colliders.remove(&(cx, cy)) {
self.physics_manager.world.remove_collider(handle);
}
let handle = self.physics_manager.world.insert_collider(collider, None);
self.chunk_colliders.insert((cx, cy), handle);
}
pub fn new() -> Self {
RbManager {
chunk_colliders: FxHashMap::default(),
physics_manager: PhysicsManager::new(),
debug_line_buffer: DebugLineBuffer::default(),
}
}
}
|
