use std::sync::Arc;
use bevy::math::IVec3;
use bevy::prelude::*;
use crate::chunk::Chunk;
use crate::voxel::VoxelType;
use super::{ChunkGenerator, GeneratorResource};
pub trait RegionGenerator<V: VoxelType>: Send + Sync + 'static {
fn applies_to(&self, chunk_pos: IVec3) -> bool;
fn generate(&self, chunk_pos: IVec3, chunk: &mut Chunk<V>);
}
impl<V: VoxelType, G: ChunkGenerator<V>> RegionGenerator<V> for G {
#[inline]
fn applies_to(&self, _chunk_pos: IVec3) -> bool {
true
}
#[inline]
fn generate(&self, chunk_pos: IVec3, chunk: &mut Chunk<V>) {
ChunkGenerator::generate(self, chunk_pos, chunk)
}
}
pub struct MultiGenerator<V: VoxelType> {
regions: Vec<Box<dyn RegionGenerator<V>>>,
fallback: Box<dyn ChunkGenerator<V>>,
}
impl<V: VoxelType> MultiGenerator<V> {
pub fn new(fallback: Box<dyn ChunkGenerator<V>>) -> Self {
Self {
regions: Vec::new(),
fallback,
}
}
pub fn add_region(&mut self, region: Box<dyn RegionGenerator<V>>) -> &mut Self {
self.regions.push(region);
self
}
pub fn with_region(mut self, region: Box<dyn RegionGenerator<V>>) -> Self {
self.regions.push(region);
self
}
pub fn with_fallback(mut self, fallback: Box<dyn ChunkGenerator<V>>) -> Self {
self.fallback = fallback;
self
}
pub fn region_count(&self) -> usize {
self.regions.len()
}
}
impl<V: VoxelType> ChunkGenerator<V> for MultiGenerator<V> {
fn generate(&self, coord: IVec3, chunk: &mut Chunk<V>) {
for region in &self.regions {
if region.applies_to(coord) {
region.generate(coord, chunk);
return;
}
}
self.fallback.generate(coord, chunk);
}
}
pub struct MultiGeneratorPlugin<V: VoxelType> {
multi: std::sync::Mutex<Option<MultiGenerator<V>>>,
}
impl<V: VoxelType> MultiGeneratorPlugin<V> {
pub fn new(fallback: Box<dyn ChunkGenerator<V>>) -> Self {
Self {
multi: std::sync::Mutex::new(Some(MultiGenerator::new(fallback))),
}
}
pub fn from_generator(multi: MultiGenerator<V>) -> Self {
Self {
multi: std::sync::Mutex::new(Some(multi)),
}
}
pub fn add_region(self, region: Box<dyn RegionGenerator<V>>) -> Self {
{
let mut guard = self.multi.lock().expect("MultiGeneratorPlugin mutex");
guard
.as_mut()
.expect("MultiGeneratorPlugin already consumed")
.add_region(region);
}
self
}
pub fn with_fallback(self, fallback: Box<dyn ChunkGenerator<V>>) -> Self {
{
let mut guard = self.multi.lock().expect("MultiGeneratorPlugin mutex");
let multi = guard.take().expect("MultiGeneratorPlugin already consumed");
*guard = Some(multi.with_fallback(fallback));
}
self
}
}
impl<V: VoxelType> Plugin for MultiGeneratorPlugin<V> {
fn build(&self, app: &mut App) {
let multi = self
.multi
.lock()
.expect("MultiGeneratorPlugin mutex")
.take()
.expect("MultiGeneratorPlugin built twice or never seeded");
app.insert_resource(GeneratorResource::<V> {
generator: Arc::new(multi),
});
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::chunk::CHUNK_SIZE;
use crate::voxel::DefaultVoxel;
struct PositiveX;
impl RegionGenerator<DefaultVoxel> for PositiveX {
fn applies_to(&self, chunk_pos: IVec3) -> bool {
chunk_pos.x >= 0
}
fn generate(&self, _chunk_pos: IVec3, chunk: &mut Chunk<DefaultVoxel>) {
chunk.set(0, 0, 0, DefaultVoxel::Rock);
}
}
struct NegativeX;
impl RegionGenerator<DefaultVoxel> for NegativeX {
fn applies_to(&self, chunk_pos: IVec3) -> bool {
chunk_pos.x < 0
}
fn generate(&self, _chunk_pos: IVec3, chunk: &mut Chunk<DefaultVoxel>) {
chunk.set(0, 0, 0, DefaultVoxel::IronOre);
}
}
struct VoidFallback;
impl ChunkGenerator<DefaultVoxel> for VoidFallback {
fn generate(&self, _coord: IVec3, chunk: &mut Chunk<DefaultVoxel>) {
chunk.set(1, 1, 1, DefaultVoxel::RareMineral);
}
}
#[test]
fn region_dispatch_positive_x_runs_first_region() {
let multi = MultiGenerator::<DefaultVoxel>::new(Box::new(VoidFallback))
.with_region(Box::new(PositiveX))
.with_region(Box::new(NegativeX));
let mut chunk = Chunk::<DefaultVoxel>::new();
ChunkGenerator::generate(&multi, IVec3::new(5, 0, 0), &mut chunk);
assert_eq!(chunk.get(0, 0, 0), DefaultVoxel::Rock);
assert_eq!(chunk.get(1, 1, 1), DefaultVoxel::Air);
}
#[test]
fn region_dispatch_negative_x_runs_second_region() {
let multi = MultiGenerator::<DefaultVoxel>::new(Box::new(VoidFallback))
.with_region(Box::new(PositiveX))
.with_region(Box::new(NegativeX));
let mut chunk = Chunk::<DefaultVoxel>::new();
ChunkGenerator::generate(&multi, IVec3::new(-3, 0, 0), &mut chunk);
assert_eq!(chunk.get(0, 0, 0), DefaultVoxel::IronOre);
assert_eq!(chunk.get(1, 1, 1), DefaultVoxel::Air);
}
#[test]
fn fallback_runs_when_no_region_matches() {
struct Never;
impl RegionGenerator<DefaultVoxel> for Never {
fn applies_to(&self, _: IVec3) -> bool {
false
}
fn generate(&self, _: IVec3, chunk: &mut Chunk<DefaultVoxel>) {
chunk.set(0, 0, 0, DefaultVoxel::Rock);
}
}
let multi = MultiGenerator::<DefaultVoxel>::new(Box::new(VoidFallback))
.with_region(Box::new(Never));
let mut chunk = Chunk::<DefaultVoxel>::new();
ChunkGenerator::generate(&multi, IVec3::new(0, 0, 0), &mut chunk);
assert_eq!(chunk.get(1, 1, 1), DefaultVoxel::RareMineral);
assert_eq!(chunk.get(0, 0, 0), DefaultVoxel::Air);
}
#[test]
fn insertion_order_wins_on_overlap() {
struct AllRock;
impl RegionGenerator<DefaultVoxel> for AllRock {
fn applies_to(&self, _: IVec3) -> bool {
true
}
fn generate(&self, _: IVec3, chunk: &mut Chunk<DefaultVoxel>) {
chunk.set(0, 0, 0, DefaultVoxel::Rock);
}
}
struct AllIron;
impl RegionGenerator<DefaultVoxel> for AllIron {
fn applies_to(&self, _: IVec3) -> bool {
true
}
fn generate(&self, _: IVec3, chunk: &mut Chunk<DefaultVoxel>) {
chunk.set(0, 0, 0, DefaultVoxel::IronOre);
}
}
let multi = MultiGenerator::<DefaultVoxel>::new(Box::new(VoidFallback))
.with_region(Box::new(AllRock))
.with_region(Box::new(AllIron));
let mut chunk = Chunk::<DefaultVoxel>::new();
ChunkGenerator::generate(&multi, IVec3::ZERO, &mut chunk);
assert_eq!(chunk.get(0, 0, 0), DefaultVoxel::Rock);
}
#[test]
fn blanket_impl_lets_chunk_generator_serve_as_region() {
let multi = MultiGenerator::<DefaultVoxel>::new(Box::new(VoidFallback))
.with_region(Box::new(VoidFallback));
let mut chunk = Chunk::<DefaultVoxel>::new();
ChunkGenerator::generate(&multi, IVec3::new(7, 7, 7), &mut chunk);
let mut nonair = 0;
for x in 0..CHUNK_SIZE {
for y in 0..CHUNK_SIZE {
for z in 0..CHUNK_SIZE {
if chunk.get(x, y, z) != DefaultVoxel::Air {
nonair += 1;
}
}
}
}
assert_eq!(
nonair, 1,
"exactly one voxel should be set; got {nonair} non-air voxels"
);
}
}