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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
use glam::IVec2;
use rapier2d::dynamics::RigidBodyBuilder;
use crate::{
content::materials::MaterialId,
sim::{
cell::Cell,
entity::{EntityCells, EntityDef, EntityId, EntityUpdateResult},
lib::components::compute_components,
sim_manager::SimManager,
},
};
fn write_entity_to_world(sim: &mut SimManager, entity_id: EntityId) -> Vec<(u8, u8, i32, i32)> {
let mut cells_written: Vec<(u8, u8, i32, i32)> = Vec::new();
if let Some(entity) = sim.entities.get(&entity_id)
&& let Some(cells) = &entity.data.cells
&& let Some((pos, (cos, sin))) = entity.data._transform(&sim.rb_manager)
{
let (half_size_x, half_size_y) = ((cells.size.x / 2) as f32, (cells.size.y / 2) as f32);
// half-extent of the rotated grid's axis-aligned bounding box, plus a cell of margin
let (radius_x, radius_y) = (
half_size_x * (cos.abs() + sin.abs()) + 1.0,
half_size_y * (cos.abs() + sin.abs()) + 1.0,
);
let world_xl = (pos.x - radius_x).floor() as i32;
let world_xu = (pos.x + radius_x).ceil() as i32;
let world_yl = (pos.y - radius_y).floor() as i32;
let world_yu = (pos.y + radius_y).ceil() as i32;
for world_x in world_xl..=world_xu {
for world_y in world_yl..=world_yu {
if let Some(cur_world_cell) = sim
.cell_manager
.get_cell_from_game_position(world_x, world_y)
&& cur_world_cell.material == MaterialId::Void
{
// same as shader
let d = (world_x as f32 + 0.5 - pos.x, world_y as f32 + 0.5 - pos.y);
let q = (d.0.floor() + 0.5, d.1.floor() + 0.5);
let (lx, ly) = (
(q.0 * cos + q.1 * sin + half_size_x).floor() as i32,
(-q.0 * sin + q.1 * cos + half_size_y).floor() as i32,
);
if lx < 0 || ly < 0 || lx >= cells.size.x || ly >= cells.size.y {
continue;
}
let mut cell = cells.get_cell_at_local_position(IVec2::new(lx, ly));
if cell.material == MaterialId::Void {
continue;
}
cell.match_parity(sim.cell_manager.seqno);
// TODO: OPTIMIZE!!
sim.cell_manager
.set_cell_from_game_position(world_x, world_y, cell, false);
cells_written.push((lx as u8, ly as u8, world_x, world_y));
}
}
}
}
cells_written
}
pub fn write_entities_to_world(
sim: &mut SimManager,
// (entity_x, entity_y, cell_x, cell_y)
) -> Vec<(EntityId, Vec<(u8, u8, i32, i32)>)> {
puffin::profile_function!();
// TODO optimize
let entity_ids: Vec<EntityId> = sim.entities.keys().copied().collect();
let mut cells_written_by_entity: Vec<(EntityId, Vec<(u8, u8, i32, i32)>)> = Vec::new();
for entity_id in entity_ids {
let cells_written = write_entity_to_world(sim, entity_id);
cells_written_by_entity.push((entity_id, cells_written));
}
cells_written_by_entity
}
// TODO optimize
pub fn read_back_entities_from_world(
sim: &mut SimManager,
cells_written_by_entity: Vec<(EntityId, Vec<(u8, u8, i32, i32)>)>,
) {
puffin::profile_function!();
for (entity_id, cells_written) in cells_written_by_entity {
let mut entity = sim.entities.get_mut(&entity_id);
let mut should_update_entity = false;
for (lx, ly, x, y) in cells_written {
// update the entity
// TODO optimize
let new_local_cell = sim.cell_manager.get_cell_from_game_position(x, y).unwrap();
if !new_local_cell.entity_integrated() {
// this means that the entity changed in some way, so we should recompute its shape
// TODO wait N frames to debounce this
should_update_entity = true;
}
if let Some(entity) = &mut entity {
let entity_cells = entity.data.cells.as_mut().unwrap();
// we do this unconditionally because it's cheaper than checking if it actually needs to be updated
// and because we don't have a good way to track changes to cell state
entity_cells
.set_cell_at_local_position(IVec2::new(lx as i32, ly as i32), new_local_cell);
}
// update the world
// TODO optimize
sim.cell_manager
.set_cell_from_game_position(x, y, Cell::void(), false);
}
if let Some(entity) = &mut entity
&& should_update_entity
{
// correctness: there's no way to get here if the entity is an uncelled entity
let ec = entity.data.cells.as_mut().unwrap();
// first check if the entity has been partitioned
let components = compute_components(&ec.cells, ec.size.x, ec.size.y);
if components.len() == 0 {
panic!("The entity was completely destroyed?")
} else if components.len() == 1 {
// the entity's cells were changed, but not partitioned
puffin::profile_scope!("Recompute collider");
if let Some(new_collider) = entity.compute_collider() {
// don't profile this separately as it's basically free
sim.rb_manager
.physics_manager
.world
.remove_collider(entity.data.collider_h.unwrap());
let new_handle = sim
.rb_manager
.physics_manager
.world
.insert_collider(new_collider, Some(entity.data.rb_h.unwrap()));
entity.data.collider_h = Some(new_handle);
}
} else {
// the entity was partitioned
// destroy the original entity
// correctness -- not correct! because we don't have pos without rb
puffin::profile_scope!("Partition entity");
let old_rb = sim
.rb_manager
.physics_manager
.world
.bodies
.get(entity.data.rb_h.unwrap())
.unwrap();
let old_pose = old_rb.position().clone();
let old_linvel = old_rb.linvel().clone();
let old_angvel = old_rb.angvel().clone();
sim.destroy_entity(entity_id);
// and create a new entity for each component
for component in components {
let r = old_pose.transform_vector(component.position);
let mut pose = old_pose;
pose.translation += r;
let rb = RigidBodyBuilder::dynamic()
.pose(pose)
.linvel(old_linvel)
.angvel(old_angvel)
.build();
let def = EntityDef::from_cells_and_rb(
EntityCells {
cells: component.cells,
size: component.size,
},
rb,
None,
);
sim.create_entity(def);
}
}
}
}
}
pub fn process_entity_update_result(sim: &mut SimManager, result: EntityUpdateResult) {
for d in result.deferred_destructions {
sim.destroy_entity(d);
}
}
|
