use bevy::prelude::*;
use crate::chunk::Chunk;
use crate::generator::GeneratorSystems;
use crate::voxel::VoxelType;
use crate::world::{ChunkManager, ChunkModified};
const NEIGHBOR_DIRS: [IVec3; 6] = [
IVec3::new(1, 0, 0),
IVec3::new(-1, 0, 0),
IVec3::new(0, 1, 0),
IVec3::new(0, -1, 0),
IVec3::new(0, 0, 1),
IVec3::new(0, 0, -1),
];
pub fn is_chunk_occluded<V: VoxelType>(
coord: IVec3,
manager: &ChunkManager,
chunks: &Query<&Chunk<V>>,
) -> bool {
for dir in NEIGHBOR_DIRS {
let neighbor_coord = coord + dir;
let Some(entity) = manager.get_entity(neighbor_coord) else {
return false;
};
let Ok(chunk) = chunks.get(entity) else {
return false;
};
if !chunk.is_fully_solid() {
return false;
}
}
true
}
pub fn occlusion_update_system<V: VoxelType>(
mut modified_reader: MessageReader<ChunkModified>,
manager: Res<ChunkManager>,
chunks: Query<&Chunk<V>>,
mut visibility: Query<&mut Visibility>,
) {
crate::profile_span!("voxel::world::occlusion");
let mut to_check: Vec<IVec3> = Vec::new();
for &ChunkModified(coord) in modified_reader.read() {
to_check.push(coord);
for dir in NEIGHBOR_DIRS {
to_check.push(coord + dir);
}
}
to_check.sort_unstable_by(|a, b| a.x.cmp(&b.x).then(a.y.cmp(&b.y)).then(a.z.cmp(&b.z)));
to_check.dedup();
for coord in to_check {
let Some(entity) = manager.get_entity(coord) else {
continue;
};
let Ok(mut vis) = visibility.get_mut(entity) else {
continue;
};
let occluded = is_chunk_occluded::<V>(coord, &manager, &chunks);
*vis = if occluded {
Visibility::Hidden
} else {
Visibility::Visible
};
}
}
pub struct OcclusionPlugin<V: VoxelType> {
_marker: std::marker::PhantomData<V>,
}
impl<V: VoxelType> OcclusionPlugin<V> {
pub fn new() -> Self {
Self {
_marker: std::marker::PhantomData,
}
}
}
impl<V: VoxelType> Default for OcclusionPlugin<V> {
fn default() -> Self {
Self::new()
}
}
impl<V: VoxelType> Plugin for OcclusionPlugin<V> {
fn build(&self, app: &mut App) {
app.add_systems(Update, occlusion_update_system::<V>.after(GeneratorSystems));
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::chunk::CHUNK_SIZE;
use crate::voxel::DefaultVoxel;
fn make_solid_chunk() -> Chunk<DefaultVoxel> {
let mut chunk = Chunk::<DefaultVoxel>::new();
for x in 0..CHUNK_SIZE {
for y in 0..CHUNK_SIZE {
for z in 0..CHUNK_SIZE {
chunk.set(x, y, z, DefaultVoxel::Rock);
}
}
}
chunk
}
#[test]
fn test_not_occluded_when_neighbor_missing() {
use bevy::ecs::system::SystemState;
let mut app = App::new();
let center = app.world_mut().spawn(make_solid_chunk()).id();
let mut manager = ChunkManager::default();
manager.register(IVec3::ZERO, center);
app.world_mut().insert_resource(manager);
let mut state: SystemState<(Res<ChunkManager>, Query<&Chunk<DefaultVoxel>>)> =
SystemState::new(app.world_mut());
let (manager, query) = state.get(app.world());
let result = is_chunk_occluded::<DefaultVoxel>(IVec3::ZERO, &manager, &query);
assert!(!result, "chunk with missing neighbor must not be occluded");
}
#[test]
fn test_not_occluded_when_neighbor_not_solid() {
use bevy::ecs::system::SystemState;
let mut app = App::new();
let center = app.world_mut().spawn(make_solid_chunk()).id();
let air_neighbor = app
.world_mut()
.spawn(Chunk::<DefaultVoxel>::new()) .id();
let mut manager = ChunkManager::default();
manager.register(IVec3::ZERO, center);
manager.register(IVec3::new(1, 0, 0), air_neighbor);
app.world_mut().insert_resource(manager);
let mut state: SystemState<(Res<ChunkManager>, Query<&Chunk<DefaultVoxel>>)> =
SystemState::new(app.world_mut());
let (manager, query) = state.get(app.world());
let result = is_chunk_occluded::<DefaultVoxel>(IVec3::ZERO, &manager, &query);
assert!(!result, "chunk with air neighbor must not be occluded");
}
}