Mirrored_Repos/veloren
1
0
Fork 0
mirror of https://gitlab.com/veloren/veloren.git synced 2024-08-30 18:12:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Zoomy worldgen WIP, please do not complain things are broken.

Browse Source
This commit is contained in:
Joshua Yanovski 2022-06-24 02:48:09 -07:00
parent a073307072
commit a973155597
29 changed files with 7374 additions and 1610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Cargo.lock generated
View File

@ -3686,6 +3686,15 @@ dependencies = [
"rand_xorshift",
]
[[package]]
name = "noisy_float"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "978fe6e6ebc0bf53de533cd456ca2d9de13de13856eda1518a285d7705a213af"
dependencies = [
"num-traits",
]
[[package]]
name = "nom"
version = "4.2.3"
@ -6950,6 +6959,7 @@ dependencies = [
"arr_macro",
"bincode",
"bitvec",
"bumpalo",
"clap 3.1.8",
"criterion",
"csv",
@ -6966,6 +6976,7 @@ dependencies = [
"lz-fear",
"minifb",
"noise",
"noisy_float",
"num 0.4.0",
"num-traits",
"ordered-float 2.10.0",

2
client/src/lib.rs
View File

@ -1777,7 +1777,7 @@ impl Client {
for key in keys.iter() {
if self.state.terrain().get_key(*key).is_none() {
if !skip_mode && !self.pending_chunks.contains_key(key) {
const TOTAL_PENDING_CHUNKS_LIMIT: usize = 12;
const TOTAL_PENDING_CHUNKS_LIMIT: usize = 1024;
const CURRENT_TICK_PENDING_CHUNKS_LIMIT: usize = 2;
if self.pending_chunks.len() < TOTAL_PENDING_CHUNKS_LIMIT
&& current_tick_send_chunk_requests

2
common/assets/src/lib.rs
View File

@ -7,7 +7,7 @@ use lazy_static::lazy_static;
use std::{borrow::Cow, path::PathBuf, sync::Arc};
pub use assets_manager::{
asset::{DirLoadable, Ron},
asset::{DirLoadable, NotHotReloaded, Ron},
loader::{
self, BincodeLoader, BytesLoader, JsonLoader, LoadFrom, Loader, RonLoader, StringLoader,
},

4
common/src/grid.rs
View File

@ -77,9 +77,9 @@ impl<T> Grid<T> {
&self,
pos: Vec2<i32>,
size: Vec2<i32>,
) -> impl Iterator<Item = Option<(Vec2<i32>, &T)>> + '_ {
) -> impl Iterator<Item = (Vec2<i32>, &T)> + '_ {
(0..size.x).flat_map(move |x| {
(0..size.y).map(move |y| {
(0..size.y).flat_map(move |y| {
Some((
pos + Vec2::new(x, y),
&self.cells[self.idx(pos + Vec2::new(x, y))?],

1
common/src/lib.rs
View File

@ -7,6 +7,7 @@
associated_type_defaults,
bool_to_option,
fundamental,
generic_const_exprs,
label_break_value,
option_zip,
trait_alias,

4
common/src/store.rs
View File

@ -84,6 +84,10 @@ impl<T> Store<T> {
Some(Id::<T>(i, PhantomData))
}
}
pub fn len(&self) -> usize {
self.items.len()
}
}
impl<T: Send + Sync> Store<T> {

12
common/src/terrain/structure.rs
View File

@ -55,6 +55,7 @@ pub struct Structure {
#[derive(Debug)]
struct BaseStructure {
len: usize,
vol: Dyna<Option<NonZeroU8>, ()>,
palette: [StructureBlock; 256],
}
@ -68,6 +69,8 @@ impl std::ops::Deref for StructuresGroup {
}
impl assets::Compound for StructuresGroup {
const HOT_RELOADED: bool = false;
fn load<S: assets::source::Source + ?Sized>(
cache: &assets::AssetCache<S>,
specifier: &str,
@ -100,6 +103,8 @@ impl assets::Compound for StructuresGroup {
}
}
impl assets::NotHotReloaded for StructuresGroup {}
impl Structure {
pub fn load_group(specifier: &str) -> AssetHandle<StructuresGroup> {
StructuresGroup::load_expect(&["world.manifests.", specifier].concat())
@ -117,6 +122,10 @@ impl Structure {
max: self.base.vol.size().map(|e| e as i32) - self.center,
}
}
pub fn len(&self) -> usize {
self.base.len
}
}
impl BaseVol for Structure {
@ -171,11 +180,12 @@ impl assets::Compound for BaseStructure {
);
}
Ok(BaseStructure { vol, palette })
Ok(BaseStructure { len: model.voxels.len(), vol, palette })
} else {
Ok(BaseStructure {
vol: Dyna::filled(Vec3::zero(), None, ()),
palette: [StructureBlock::None; 256],
len: 0,
})
}
}

10
world/Cargo.toml
View File

@ -5,7 +5,11 @@ authors = ["Joshua Barretto <joshua.s.barretto@gmail.com>"]
edition = "2021"
[features]
simd = ["vek/platform_intrinsics", "packed_simd"]
simd = [
"vek/platform_intrinsics",
# "vek/vec8",
"packed_simd",
]
bin_compression = ["lz-fear", "deflate", "flate2", "image/jpeg", "num-traits", "fallible-iterator", "clap", "rstar"]
default = ["simd"]
@ -17,12 +21,14 @@ common-net = { package = "veloren-common-net", path = "../common/net" }
bincode = "1.3.1"
bitvec = "0.22"
bumpalo = "3.9.1"
enum-iterator = "0.7"
fxhash = "0.2.1"
image = { version = "0.23.12", default-features = false, features = ["png"] }
itertools = "0.10"
vek = { version = "0.15.8", features = ["serde"] }
noise = { version = "0.7", default-features = false }
noisy_float = { version = "0.2", default-features = false }
num = "0.4"
ordered-float = "2.0.1"
hashbrown = { version = "0.11", features = ["rayon", "serde", "nightly"] }
@ -50,7 +56,7 @@ clap = { version = "3.1.8", optional = true }
[dev-dependencies]
common-frontend = { package = "veloren-common-frontend", path = "../common/frontend" }
criterion = "0.3"
criterion = { version = "0.3", features = ["real_blackbox"] }
csv = "1.1.3"
tracing-subscriber = { version = "0.3.7", default-features = false, features = ["fmt", "time", "ansi", "smallvec", "env-filter"] }
minifb = "0.22"

362
world/benches/site2.rs
View File

@ -1,92 +1,226 @@
use common::{
generation::EntityInfo,
store::{Id, Store},
terrain::Block,
terrain::{Block, BlockKind, SpriteKind, TerrainChunk, TerrainChunkMeta, TerrainChunkSize},
vol::RectVolSize,
};
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use hashbrown::HashMap;
use rand::prelude::*;
use rayon::ThreadPoolBuilder;
use vek::{Vec2, Vec3};
use vek::{Aabr, Rgb, Vec2, Vec3};
use veloren_world::{
config::CONFIG,
sim::{FileOpts, WorldOpts, DEFAULT_WORLD_MAP},
site2::{
plot::PlotKind, Fill,
Primitive, Site, Structure,
},
site2::{plot::PlotKind, Fill, Filler, Plot, Primitive, Site, Structure},
CanvasInfo, Land, World,
};
#[allow(dead_code)]
/* #[allow(dead_code)]
fn count_prim_kinds(prims: &Store<Primitive>) -> HashMap<String, usize> {
let mut ret = HashMap::new();
for prim in prims.values() {
match &prim {
Primitive::Empty => { *ret.entry("Empty".to_string()).or_default() += 1; }
Primitive::Aabb(_) => { *ret.entry("Aabb".to_string()).or_default() += 1; }
Primitive::Pyramid { .. } => { *ret.entry("Pyramid".to_string()).or_default() += 1; }
Primitive::Ramp { .. } => { *ret.entry("Ramp".to_string()).or_default() += 1; },
Primitive::Gable { .. } => { *ret.entry("Gable".to_string()).or_default() += 1; },
Primitive::Cylinder(_) => { *ret.entry("Cylinder".to_string()).or_default() += 1; },
Primitive::Cone(_) => { *ret.entry("Cone".to_string()).or_default() += 1; },
Primitive::Sphere(_) => { *ret.entry("Sphere".to_string()).or_default() += 1; },
Primitive::Superquadric { .. } => { *ret.entry("Superquadratic".to_string()).or_default() += 1; },
Primitive::Plane(_, _, _) => { *ret.entry("Plane".to_string()).or_default() += 1; },
Primitive::Segment { .. } => { *ret.entry("Segment".to_string()).or_default() += 1; },
Primitive::SegmentPrism { .. } => { *ret.entry("SegmentPrism".to_string()).or_default() += 1; },
Primitive::Sampling(_, _) => { *ret.entry("Sampling".to_string()).or_default() += 1; },
Primitive::Prefab(_) => { *ret.entry("Prefab".to_string()).or_default() += 1; },
Primitive::Intersect(_, _) => { *ret.entry("Intersect".to_string()).or_default() += 1; },
Primitive::Union(_, _) => { *ret.entry("Union".to_string()).or_default() += 1; },
Primitive::Without(_, _) => { *ret.entry("Without".to_string()).or_default() += 1; },
Primitive::RotateAbout(_, _, _) => { *ret.entry("RotateAbout".to_string()).or_default() += 1; },
Primitive::Translate(_, _) => { *ret.entry("Translate".to_string()).or_default() += 1; },
Primitive::Scale(_, _) => { *ret.entry("Scale".to_string()).or_default() += 1; },
Primitive::Repeat(_, _, _) => { *ret.entry("Repeat".to_string()).or_default() += 1; },
Primitive::Empty => {
*ret.entry("Empty".to_string()).or_default() += 1;
},
Primitive::Aabb(_) => {
*ret.entry("Aabb".to_string()).or_default() += 1;
},
Primitive::Pyramid { .. } => {
*ret.entry("Pyramid".to_string()).or_default() += 1;
},
Primitive::Ramp { .. } => {
*ret.entry("Ramp".to_string()).or_default() += 1;
},
Primitive::Gable { .. } => {
*ret.entry("Gable".to_string()).or_default() += 1;
},
Primitive::Cylinder(_) => {
*ret.entry("Cylinder".to_string()).or_default() += 1;
},
Primitive::Cone(_) => {
*ret.entry("Cone".to_string()).or_default() += 1;
},
Primitive::Sphere(_) => {
*ret.entry("Sphere".to_string()).or_default() += 1;
},
Primitive::Superquadric { .. } => {
*ret.entry("Superquadratic".to_string()).or_default() += 1;
},
Primitive::Plane(_, _, _) => {
*ret.entry("Plane".to_string()).or_default() += 1;
},
Primitive::Segment { .. } => {
*ret.entry("Segment".to_string()).or_default() += 1;
},
Primitive::SegmentPrism { .. } => {
*ret.entry("SegmentPrism".to_string()).or_default() += 1;
},
Primitive::Sampling(_, _) => {
*ret.entry("Sampling".to_string()).or_default() += 1;
},
Primitive::Prefab(_) => {
*ret.entry("Prefab".to_string()).or_default() += 1;
},
Primitive::Intersect(_, _) => {
*ret.entry("Intersect".to_string()).or_default() += 1;
},
Primitive::Union(_, _) => {
*ret.entry("Union".to_string()).or_default() += 1;
},
Primitive::Without(_, _) => {
*ret.entry("Without".to_string()).or_default() += 1;
},
Primitive::RotateAbout(_, _, _) => {
*ret.entry("RotateAbout".to_string()).or_default() += 1;
},
Primitive::Translate(_, _) => {
*ret.entry("Translate".to_string()).or_default() += 1;
},
Primitive::Scale(_, _) => {
*ret.entry("Scale".to_string()).or_default() += 1;
},
Primitive::Repeat(_, _, _) => {
*ret.entry("Repeat".to_string()).or_default() += 1;
},
}
}
ret
}
} */
fn render_plots(canvas: &CanvasInfo<'_>, site: &Site) {
fn render_plots<'a>(/*canvas: &mut Canvas<'a>,*/
arena: &'a mut bumpalo::Bump,
info: CanvasInfo<'a>,
site: &'a Site,
render_area: Aabr<i32>,
) {
for plot in site.plots() {
let result = match &plot.kind() {
PlotKind::House(house) => house.render_collect(site, canvas),
PlotKind::Workshop(workshop) => workshop.render_collect(site, canvas),
PlotKind::Castle(castle) => castle.render_collect(site, canvas),
PlotKind::Dungeon(dungeon) => dungeon.render_collect(site, canvas),
PlotKind::Gnarling(gnarling) => gnarling.render_collect(site, canvas),
PlotKind::GiantTree(giant_tree) => giant_tree.render_collect(site, canvas),
let structure: &dyn Structure<_> = match plot.kind() {
PlotKind::House(house) => house,
PlotKind::Workshop(workshop) => workshop,
PlotKind::Castle(castle) => castle,
PlotKind::Dungeon(dungeon) => dungeon,
PlotKind::Gnarling(gnarling) => gnarling,
PlotKind::GiantTree(giant_tree) => giant_tree,
PlotKind::CliffTower(cliff_tower) => cliff_tower,
PlotKind::Citadel(citadel) => citadel,
_ => continue,
};
//println!("{:?}", count_prim_kinds(&result.0));
iter_fills(canvas, result);
let mut null_canvas = NullCanvas;
let result = structure.render_collect(site, /*canvas*/arena, info, render_area, /*|_canvas| */&mut null_canvas);
// NOTE: Clearing out the primitives between renders costs us nothing, because any
// chunks that get deallocated were going to be eventually deallocated anyway, while
// the current chunk remains for reuse. So this just ends up saving memory.
arena.reset();
/* //println!("{:?}", count_prim_kinds(&result.0));
iter_fills(canvas, site, plot, result); */
}
}
fn iter_fills(
canvas: &CanvasInfo<'_>,
(prim_tree, fills, _): (Store<Primitive>, Vec<(Id<Primitive>, Fill)>, Vec<EntityInfo>),
) {
for (prim, fill) in fills {
let aabb = Fill::get_bounds(&prim_tree, prim);
/// Null canvas for avoiding writing to the real cnavas.
struct NullCanvas;
impl Filler for NullCanvas {
#[inline]
fn map<F: Fill>(&mut self, pos: Vec3<i32>, f: F) {
// black_box(pos);
// black_box(f);
// black_box(f.sample_at(pos, Block::empty()));
black_box((pos, if F::NEEDS_BLOCK {
f.sample_at(pos, black_box(Block::empty()))
} else /* if F::NEEDS_POS {
f.sample_at(pos, Block::empty())
} else */{
f.sample_at(pos, Block::empty())
}));
}
for x in aabb.min.x..aabb.max.x {
for y in aabb.min.y..aabb.max.y {
for z in aabb.min.z..aabb.max.z {
let pos = Vec3::new(x, y, z);
black_box(fill.sample_at(
#[inline]
fn spawn(&mut self, entity: EntityInfo) {
black_box(entity);
}
}
/* fn iter_fills(
canvas: &CanvasInfo<'_>,
_site: &Site,
_plot: &Plot,
(prim_tree, fills, _): (
Store<Primitive>,
Vec<(Id<Primitive>, Fill)>,
Vec<EntityInfo>,
),
) {
let arena = bumpalo::Bump::new();
let mut cache = HashMap::default();
/* let wpos2d = canvas.wpos();
let chunk_aabr = Aabr {
min: wpos2d,
max: wpos2d + TerrainChunkSize::RECT_SIZE.as_::<i32>(),
}; */
/* let info = canvas.info(); */
for (prim, fill) in fills {
let aabb = Fill::get_bounds(&mut cache, &prim_tree, prim)/*Aabr::new_empty(Vec2::zero())*/;
// let mut aabb = Fill::get_bounds(&prim_tree, prim);
/* fill.sample_at(
&arena,
&mut cache,
&prim_tree,
prim,
aabb.into(),
|pos, f| canvas.map(pos, f)
); */
/*Fill::get_bounds_disjoint*/fill.sample_at(&arena, &mut cache, &prim_tree, prim, aabb.into(), canvas, /* |pos| {
/* canvas.map(pos, |block| {
let current_block =
fill.sample_at(
/* &mut bounds_cache,
&prim_tree,
prim,
prim, */
pos,
canvas,
Block::empty(),
));
&info,
block,
);
/* if let (Some(last_block), None) = (last_block, current_block) {
spawn(pos, last_block);
}
last_block = current_block; */
current_block.unwrap_or(block)
}); */
black_box(/*fill.sample_at(pos, canvas, Block::empty())*/pos);
}*/&mut NullCanvas);
/* for /*mut */aabb in Fill::get_bounds_disjoint(&mut cache, &prim_tree, prim) {
/* aabb.min = Vec2::max(aabb.min.xy(), chunk_aabr.min).with_z(aabb.min.z);
aabb.max = Vec2::min(aabb.max.xy(), chunk_aabr.max).with_z(aabb.max.z); */
for x in aabb.min.x..aabb.max.x {
for y in aabb.min.y..aabb.max.y {
for z in aabb.min.z..aabb.max.z {
/* let col_tile = site.wpos_tile(Vec2::new(x, y));
if
/* col_tile.is_building() && */
col_tile
.plot()
.and_then(|p| site.plots().nth(p.id() as usize).unwrap().z_range())
.zip(plot.z_range())
.map_or(false, |(a, b)| a.end > b.end)
{
continue;
} */
let pos = Vec3::new(x, y, z);
black_box(fill.sample_at(&mut cache, &prim_tree, prim, pos, canvas, Block::empty()));
}
}
}
}
} */
}
}
} */
fn dungeon(c: &mut Criterion) {
let pool = ThreadPoolBuilder::new().build().unwrap();
@ -101,22 +235,102 @@ fn dungeon(c: &mut Criterion) {
);
let wpos = Vec2::zero();
let seed = [1; 32];
c.bench_function("generate_dungeon", |b| {
let air = Block::air(SpriteKind::Empty);
/* let stone = Block::new(
BlockKind::Rock,
zcache_grid
.get(grid_border + TerrainChunkSize::RECT_SIZE.map(|e| e as i32) / 2)
.and_then(|zcache| zcache.as_ref())
.map(|zcache| zcache.sample.stone_col)
.unwrap_or_else(|| index.colors.deep_stone_color.into()),
); */
let water = Block::new(BlockKind::Water, Rgb::zero());
let mut chunk = TerrainChunk::new(CONFIG.sea_level as i32, water, air, TerrainChunkMeta::void());
let find_bounds = |site: &Site| {
let aabr = site.plots()
.fold(
Aabr::new_empty(Vec2::zero()),
|aabr, plot| {
// NOTE: Approx
aabr.union(plot.find_bounds())
},
);
let chunks = Vec2::from(aabr.size())
.map2(TerrainChunkSize::RECT_SIZE, |e: i32, sz| (e as f32 / sz as f32).ceil() as u32);
// .as_::<i32>();
(chunks.x as u64 * chunks.y as u64, aabr)
};
let mut bench_group = |gen_name, render_name, f: fn(&Land, &mut _, _) -> _| {
c.bench_function(gen_name, |b| {
let mut rng = rand::rngs::StdRng::from_seed(seed);
b.iter(|| {
f(&Land::from_sim(world.sim()), &mut rng, wpos);
});
});
CanvasInfo::with_mock_canvas_info(index.as_index_ref(), world.sim(), |&info| {
let mut rng = rand::rngs::StdRng::from_seed(seed);
let site = f(&info.land(), &mut rng, wpos);
let mut render_dungeon_group = c.benchmark_group(render_name);
let (throughput, render_area) = find_bounds(&site);
render_dungeon_group.throughput(criterion::Throughput::Elements(throughput));
render_dungeon_group.bench_function("identity_allocator", |b| {
b.iter(|| {
let mut arena = bumpalo::Bump::new();
/* let mut canvas = Canvas {
info,
chunk: &mut chunk,
arena: &mut arena,
entities: Vec::new(),
}; */
render_plots(/*&mut canvas, */&mut arena, info, &site, render_area);
});
});
});
};
bench_group("generate_city", "render_city", Site::generate_city);
bench_group("generate_cliff_town", "render_cliff_town", Site::generate_cliff_town);
bench_group("generate_dungeon", "render_dungeon", Site::generate_dungeon);
bench_group("generate_giant_tree", "render_giant_tree", Site::generate_giant_tree);
bench_group("generate_gnarling", "render_gnarling", Site::generate_gnarling);
bench_group("generate_citadel", "render_citadel", Site::generate_citadel);
c.bench_function("generate_chunk", |b| {
// let chunk_pos = Vec2::new(9500 / 32, 29042 / 32);
let chunk_pos = (world.sim().map_size_lg().chunks() >> 1).as_();
b.iter(|| {
black_box(world.generate_chunk(index.as_index_ref(), chunk_pos, || false, None));
});
});
/* c.bench_function("generate_dungeon", |b| {
let mut rng = rand::rngs::StdRng::from_seed(seed);
b.iter(|| {
Site::generate_dungeon(&Land::empty(), &mut rng, wpos);
});
});
{
let mut render_dungeon_group = c.benchmark_group("render_dungeon");
render_dungeon_group.bench_function("identity_allocator", |b| {
CanvasInfo::with_mock_canvas_info(index.as_index_ref(), world.sim(), |&info| {
let mut rng = rand::rngs::StdRng::from_seed(seed);
CanvasInfo::with_mock_canvas_info(index.as_index_ref(), world.sim(), |canvas| {
let site = Site::generate_dungeon(&canvas.land(), &mut rng, wpos);
let site = Site::generate_dungeon(&info.land(), &mut rng, wpos);
let mut render_dungeon_group = c.benchmark_group("render_dungeon");
render_dungeon_group.throughput(criterion::Throughput::Elements(find_bounds(&site)));
render_dungeon_group.bench_function("identity_allocator", |b| {
b.iter(|| {
render_plots(canvas, &site);
let mut arena = bumpalo::Bump::new();
let mut canvas = Canvas {
info,
chunk: &mut chunk,
arena: &mut arena,
entities: Vec::new(),
};
render_plots(&mut canvas, &site);
});
})
});
});
}
c.bench_function("generate_gnarling", |b| {
@ -126,17 +340,25 @@ fn dungeon(c: &mut Criterion) {
});
});
{
let mut render_gnarling_group = c.benchmark_group("render_gnarling");
render_gnarling_group.bench_function("identity_allocator", |b| {
CanvasInfo::with_mock_canvas_info(index.as_index_ref(), world.sim(), |&info| {
let mut rng = rand::rngs::StdRng::from_seed(seed);
CanvasInfo::with_mock_canvas_info(index.as_index_ref(), world.sim(), |canvas| {
let site = Site::generate_gnarling(&canvas.land(), &mut rng, wpos);
let site = Site::generate_gnarling(&info.land(), &mut rng, wpos);
let mut render_gnarling_group = c.benchmark_group("render_gnarling");
render_gnarling_group.throughput(criterion::Throughput::Elements(find_bounds(&site)));
render_gnarling_group.bench_function("identity_allocator", |b| {
b.iter(|| {
render_plots(canvas, &site);
let mut arena = bumpalo::Bump::new();
let mut canvas = Canvas {
info,
chunk: &mut chunk,
arena: &mut arena,
entities: Vec::new(),
};
render_plots(&mut canvas, &site);
});
})
});
});
}
} */
}
criterion_group!(benches, dungeon);

28
world/src/canvas.rs
View File

@ -1,6 +1,7 @@
use crate::{
block::{block_from_structure, ZCache},
column::{ColumnGen, ColumnSample},
site2::{Fill, Filler},
index::IndexRef,
land::Land,
layer::spot::Spot,
@ -41,7 +42,7 @@ impl<'a> CanvasInfo<'a> {
.into()
}
pub fn col(&self, wpos: Vec2<i32>) -> Option<&'a ColumnSample> {
pub fn col(&self, wpos: Vec2<i32>) -> Option<&'a ColumnSample<'a>> {
self.column_grid
.get(self.column_grid_border + wpos - self.wpos())
.and_then(Option::as_ref)
@ -87,7 +88,7 @@ impl<'a> CanvasInfo<'a> {
pub fn chunks(&self) -> &'a WorldSim { self.chunks }
pub fn land(&self) -> Land<'_> { Land::from_sim(self.chunks) }
pub fn land(&self) -> Land<'a> { Land::from_sim(self.chunks) }
pub fn with_mock_canvas_info<A, F: for<'b> FnOnce(&CanvasInfo<'b>) -> A>(
index: IndexRef<'a>,
@ -133,6 +134,7 @@ impl<'a> CanvasInfo<'a> {
}
pub struct Canvas<'a> {
// pub(crate) arena: &'a mut bumpalo::Bump,
pub(crate) info: CanvasInfo<'a>,
pub(crate) chunk: &'a mut TerrainChunk,
pub(crate) entities: Vec<EntityInfo>,
@ -143,7 +145,7 @@ impl<'a> Canvas<'a> {
/// sampling, etc.) being used at the same time as mutable features
/// (writing blocks). To avoid this, this method extracts the
/// inner `CanvasInfo` such that it may be used independently.
pub fn info(&mut self) -> CanvasInfo<'a> { self.info }
pub fn info(&self) -> CanvasInfo<'a> { self.info }
pub fn get(&self, pos: Vec3<i32>) -> Block {
self.chunk
@ -274,3 +276,23 @@ impl<'a> Deref for Canvas<'a> {
fn deref(&self) -> &Self::Target { &self.info }
}
impl Filler for Canvas<'_> {
#[inline]
fn map<F: Fill>(&mut self, pos: Vec3<i32>, f: F) {
Canvas::map(self, pos, |block| {
let current_block =
f.sample_at(pos, /*&info*/block);
/* if let (Some(last_block), None) = (last_block, current_block) {
spawn(pos, last_block);
}
last_block = current_block; */
current_block.unwrap_or(block)
})
}
#[inline]
fn spawn(&mut self, entity: EntityInfo) {
self.entities.push(entity);
}
}

14
world/src/civ/mod.rs
View File

@ -126,6 +126,7 @@ impl Civs {
}
},
32..=37 => (SiteKind::Gnarling, 5, (&gnarling_enemies, 40)),
// 32..=37 => (SiteKind::Citadel, 5, (&castle_enemies, 20)),
_ => (SiteKind::Dungeon, 0, (&dungeon_enemies, 40)),
};
let loc = find_site_loc(&mut ctx, avoid, size, kind)?;
@ -165,7 +166,7 @@ impl Civs {
let wpos = site.center * TerrainChunkSize::RECT_SIZE.map(|e: u32| e as i32);
let (radius, flatten_radius) = match &site.kind {
SiteKind::Settlement => (32i32, 10.0),
SiteKind::Settlement => (32i32, 10.0f32),
SiteKind::Dungeon => (8i32, 3.0),
SiteKind::Castle => (16i32, 5.0),
SiteKind::Refactor => (32i32, 10.0),
@ -173,6 +174,7 @@ impl Civs {
SiteKind::Tree => (12i32, 8.0),
SiteKind::GiantTree => (12i32, 8.0),
SiteKind::Gnarling => (16i32, 10.0),
SiteKind::Citadel => (16i32, 0.0),
};
let (raise, raise_dist, make_waypoint): (f32, i32, bool) = match &site.kind {
@ -192,7 +194,8 @@ impl Civs {
}; // Raise the town centre up a little
let pos = site.center + offs;
let factor = ((1.0
- (site.center - pos).map(|e| e as f32).magnitude() / flatten_radius)
- (site.center - pos).map(|e| e as f32).magnitude()
/ flatten_radius.max(0.01))
* 1.25)
.min(1.0);
let rng = &mut ctx.rng;
@ -266,6 +269,11 @@ impl Civs {
&mut rng,
wpos,
)),
SiteKind::Citadel => WorldSite::gnarling(site2::Site::generate_citadel(
&Land::from_sim(ctx.sim),
&mut rng,
wpos,
)),
});
sim_site.site_tmp = Some(site);
let site_ref = &index.sites[site];
@ -1235,6 +1243,7 @@ pub enum SiteKind {
Tree,
GiantTree,
Gnarling,
Citadel,
}
impl SiteKind {
@ -1339,6 +1348,7 @@ impl SiteKind {
SiteKind::Gnarling => {
(-0.3..0.4).contains(&chunk.temp) && chunk.tree_density > 0.75
},
SiteKind::Citadel => (-0.3..0.7).contains(&chunk.temp) && chunk.tree_density < 0.4,
SiteKind::GiantTree | SiteKind::Tree => chunk.tree_density > 0.4,
SiteKind::CliffTown => {
(-0.6..0.4).contains(&chunk.temp)

207
world/src/layer/tree.rs
View File

@ -2,6 +2,7 @@ use crate::{
all::*,
block::block_from_structure,
column::ColumnGen,
site2::{self, PrimitiveTransform},
util::{gen_cache::StructureGenCache, RandomPerm, Sampler, UnitChooser},
Canvas, ColumnSample,
};
@ -58,7 +59,7 @@ pub fn apply_trees_to(
// TODO: Get rid of this
#[allow(clippy::large_enum_variant)]
enum TreeModel {
Structure(Structure),
Structure(&'static Structure),
Procedural(ProceduralTree, StructureBlock),
}
@ -71,12 +72,27 @@ pub fn apply_trees_to(
}
let info = canvas.info();
let mut tree_cache = StructureGenCache::new(info.chunks().gen_ctx.structure_gen.clone());
/* let mut tree_cache = StructureGenCache::new(info.chunks().gen_ctx.structure_gen.clone()); */
canvas.foreach_col(|canvas, wpos2d, col| {
let trees = tree_cache.get(wpos2d, |wpos, seed| {
let scale = 1.0;
let inhabited = false;
// Get all the trees in range.
let render_area = Aabr {
min: info.wpos(),
max: info.wpos() + Vec2::from(info.area().size().map(|e| e as i32)),
};
let mut arena = bumpalo::Bump::new();
/*canvas.foreach_col(|canvas, wpos2d, col| {*/
info.chunks()
.get_area_trees(render_area.min, render_area.max)
.filter_map(|attr| {
info.col_or_gen(attr.pos)
.filter(|col| tree_valid_at(col, attr.seed))
.zip(Some(attr))
})
.for_each(|(col, attr)| {
let seed = attr.seed;
/* let trees = tree_cache.get(wpos2d, |wpos, seed| {
let forest_kind = *info
.chunks()
.make_forest_lottery(wpos)
@ -87,12 +103,14 @@ pub fn apply_trees_to(
if !tree_valid_at(&col, seed) {
return None;
}
} */
Some(Tree {
pos: Vec3::new(wpos.x, wpos.y, col.alt as i32),
let scale = 1.0;
let inhabited = false;
let tree = /*Some(*/Tree {
pos: Vec3::new(/*wpos.x*/attr.pos.x, /*wpos.y*/attr.pos.y, col.alt as i32),
model: 'model: {
let models: AssetHandle<_> = match forest_kind {
let models: AssetHandle<_> = match attr.forest_kind {
ForestKind::Oak if QUIRKY_RAND.chance(seed + 1, 1.0 / 16.0) => *OAK_STUMPS,
ForestKind::Oak if QUIRKY_RAND.chance(seed + 2, 1.0 / 20.0) => {
break 'model TreeModel::Procedural(
@ -198,21 +216,168 @@ pub fn apply_trees_to(
},
};
let models = models.read();
let models = models./*read*/get();
TreeModel::Structure(
models
&models
[(MODEL_RAND.get(seed.wrapping_mul(17)) / 13) as usize % models.len()]
.clone(),
/*.clone(),*/
)
},
seed,
units: UNIT_CHOOSER.get(seed),
lights: inhabited,
})
});
}/*)*/;
/* }); */
for tree in trees {
let bounds = match &tree.model {
/* criterion::black_box(tree); */
/*for tree in trees {*/
/*
arena: &'b bumpalo::Bump,
canvas_info: CanvasInfo<'c>,
render_area: Aabr<i32>,
filler: /*impl FnOnce(&'b mut Canvas<'a>) -> &'b mut F*/&'b mut F,
render: Render, */
let (bounds, hanging_sprites) = match &tree.model {
TreeModel::Structure(s) => {
site2::render_collect(
&arena,
info,
render_area,
canvas,
|painter, filler| {
painter
.prefab(s)
.translate(/*totem_pos*/tree.pos)
.fill(filler.prefab(s, tree.pos, tree.seed), filler);
},
);
arena.reset();
(s.get_bounds(), [(0.0004, SpriteKind::Beehive)].as_ref())
},
&TreeModel::Procedural(ref t, leaf_block) => {
let bounds = t.get_bounds().map(|e| e as i32);
let trunk_block = t.config.trunk_block;
let leaf_vertical_scale = t.config.leaf_vertical_scale.recip();
let branch_child_radius_lerp = t.config.branch_child_radius_lerp;
let wpos = tree.pos;
// NOTE: Technically block_from_structure isn't correct here, because it could
// lerp with position; in practice, it almost never does, and most of the other
// expensive parameters are unused.
/* let trunk_block = if let Some(block) = block_from_structure(
info.index(),
trunk_block,
wpos,
tree.pos.xy(),
tree.seed,
&col,
Block::air,
calendar,
) {
block
} else {
return;
};
let leaf_block = if let Some(block) = block_from_structure(
info.index(),
leaf_block,
wpos,
tree.pos.xy(),
tree.seed,
&col,
Block::air,
calendar,
) {
block
} else {
return;
}; */
site2::render_collect(
&arena,
info,
render_area,
canvas,
|painter, filler| {
let trunk_block = filler.block_from_structure(
trunk_block,
tree.pos.xy(),
tree.seed,
&col,
);
let leaf_block = filler.block_from_structure(
leaf_block,
tree.pos.xy(),
tree.seed,
&col,
);
t.walk(|branch, parent| {
let aabr = Aabr {
min: wpos.xy() + branch.get_aabb().min.xy().as_(),
max: wpos.xy() + branch.get_aabb().max.xy().as_(),
};
if aabr.collides_with_aabr(filler.render_aabr().as_()) {
let start =
wpos.as_::<f32>() + branch.get_line().start/*.as_()*//* - 0.5*/;
let end =
wpos.as_::<f32>() + branch.get_line().end/*.as_()*//* - 0.5*/;
let wood_radius = branch.get_wood_radius();
let leaf_radius = branch.get_leaf_radius();
let parent_wood_radius = if branch_child_radius_lerp {
parent.get_wood_radius()
} else {
wood_radius
};
let leaf_eats_wood = leaf_radius > wood_radius;
let leaf_eats_parent_wood = leaf_radius > parent_wood_radius;
if !leaf_eats_wood || !leaf_eats_parent_wood {
// Render the trunk, since it's not swallowed by its leaf.
painter
.line_two_radius(
start,
end,
parent_wood_radius,
wood_radius,
1.0,
)
.fill(/*filler.block(trunk_block)*/trunk_block, filler);
}
if leaf_eats_wood || leaf_eats_parent_wood {
// Render the leaf, since it's not *completely* swallowed
// by the trunk.
painter
.line_two_radius(
start,
end,
leaf_radius,
leaf_radius,
leaf_vertical_scale,
)
.fill(/*filler.block(leaf_block)*/leaf_block, filler);
}
true
} else {
false
}
});
// Draw the roots.
t.roots.iter().for_each(|root| {
painter
.line(
wpos/*.as_::<f32>()*/ + root.line.start.as_()/* - 0.5*/,
wpos/*.as_::<f32>()*/ + root.line.end.as_()/* - 0.5*/,
root.radius,
)
.fill(/*filler.block(leaf_block)*/trunk_block, filler);
});
},
);
arena.reset();
(bounds, t.config.hanging_sprites)
},
};
/* let bounds = match &tree.model {
TreeModel::Structure(s) => s.get_bounds(),
TreeModel::Procedural(t, _) => t.get_bounds().map(|e| e as i32),
};
@ -224,7 +389,6 @@ pub fn apply_trees_to(
// Skip this column
continue;
}
let hanging_sprites = match &tree.model {
TreeModel::Structure(_) => [(0.0004, SpriteKind::Beehive)].as_ref(),
TreeModel::Procedural(t, _) => t.config.hanging_sprites,
@ -307,9 +471,10 @@ pub fn apply_trees_to(
is_leaf_top = true;
last_block = Block::empty();
});
}
}
});
} */
/*}*/
})
/*})*/;
}
/// A type that specifies the generation properties of a tree.

16
world/src/lib.rs
View File

@ -8,10 +8,16 @@
#![allow(clippy::branches_sharing_code)] // TODO: evaluate
#![deny(clippy::clone_on_ref_ptr)]
#![feature(
arbitrary_enum_discriminant,
associated_const_equality,
bool_to_option,
label_break_value,
option_zip,
arbitrary_enum_discriminant
portable_simd,
int_log,
let_else,
map_first_last,
trait_alias,
)]
mod all;
@ -158,7 +164,7 @@ impl World {
civ::SiteKind::Castle => world_msg::SiteKind::Castle,
civ::SiteKind::Tree | civ::SiteKind::GiantTree => world_msg::SiteKind::Tree,
// TODO: Maybe change?
civ::SiteKind::Gnarling => world_msg::SiteKind::Gnarling,
civ::SiteKind::Gnarling | civ::SiteKind::Citadel => world_msg::SiteKind::Gnarling,
},
wpos: site.center * TerrainChunkSize::RECT_SIZE.map(|e| e as i32),
}
@ -347,6 +353,7 @@ impl World {
let mut dynamic_rng = ChaCha8Rng::from_seed(thread_rng().gen());
// Apply layers (paths, caves, etc.)
let mut arena = bumpalo::Bump::new();
let mut canvas = Canvas {
info: CanvasInfo {
chunk_pos,
@ -359,6 +366,7 @@ impl World {
calendar,
},
chunk: &mut chunk,
// arena: &mut arena,
entities: Vec::new(),
};
@ -392,7 +400,7 @@ impl World {
sim_chunk
.sites
.iter()
.for_each(|site| index.sites[*site].apply_to(&mut canvas, &mut dynamic_rng));
.for_each(|site| index.sites[*site].apply_to(&mut canvas, &mut arena, &mut dynamic_rng));
let mut supplement = ChunkSupplement {
entities: canvas.entities,
@ -477,7 +485,7 @@ impl World {
objects.append(
&mut self
.sim()
.get_area_trees(min_wpos, max_wpos)
.get_area_trees_par(min_wpos, max_wpos)
.filter_map(|attr| {
ColumnGen::new(self.sim())
.get((attr.pos, index, self.sim().calendar.as_ref()))

24
world/src/sim/mod.rs
View File

@ -2148,7 +2148,8 @@ impl WorldSim {
})
}
pub fn get_area_trees(
/// TOOD: Abstract over sequential and parallel iteration.
pub fn get_area_trees_par(
&self,
wpos_min: Vec2<i32>,
wpos_max: Vec2<i32>,
@ -2167,6 +2168,27 @@ impl WorldSim {
})
})
}
/// TOOD: Abstract over sequential and parallel iteration.
pub fn get_area_trees(
&self,
wpos_min: Vec2<i32>,
wpos_max: Vec2<i32>,
) -> impl Iterator<Item = TreeAttr> + '_ {
self.gen_ctx
.structure_gen
.iter(wpos_min, wpos_max)
.filter_map(move |(wpos, seed)| {
let lottery = self.make_forest_lottery(wpos);
Some(TreeAttr {
pos: wpos,
seed,
scale: 1.0,
forest_kind: *lottery.choose_seeded(seed).as_ref()?,
inhabited: false,
})
})
}
}
#[derive(Debug)]

12
world/src/site/mod.rs
View File

@ -199,18 +199,18 @@ impl Site {
}
}
pub fn apply_to<'a>(&'a self, canvas: &mut Canvas, dynamic_rng: &mut impl Rng) {
pub fn apply_to<'a>(&'a self, canvas: &mut Canvas<'a>, arena: &mut bumpalo::Bump, dynamic_rng: &mut impl Rng) {
let info = canvas.info();
let get_col = |wpos| info.col(wpos + info.wpos);
match &self.kind {
SiteKind::Settlement(s) => s.apply_to(canvas.index, canvas.wpos, get_col, canvas.chunk),
SiteKind::Dungeon(d) => d.render(canvas, dynamic_rng),
SiteKind::Dungeon(d) => d.render(canvas, arena, dynamic_rng),
SiteKind::Castle(c) => c.apply_to(canvas.index, canvas.wpos, get_col, canvas.chunk),
SiteKind::Refactor(s) => s.render(canvas, dynamic_rng),
SiteKind::CliffTown(ct) => ct.render(canvas, dynamic_rng),
SiteKind::Refactor(s) => s.render(canvas, arena, dynamic_rng),
SiteKind::CliffTown(ct) => ct.render(canvas, arena, dynamic_rng),
SiteKind::Tree(t) => t.render(canvas, dynamic_rng),
SiteKind::GiantTree(gt) => gt.render(canvas, dynamic_rng),
SiteKind::Gnarling(g) => g.render(canvas, dynamic_rng),
SiteKind::GiantTree(gt) => gt.render(canvas, arena, dynamic_rng),
SiteKind::Gnarling(g) => g.render(canvas, arena, dynamic_rng),
}
}

5115
world/src/site2/gen.rs
View File

File diff suppressed because it is too large Load Diff

117
world/src/site2/mod.rs
View File

@ -5,7 +5,7 @@ pub mod util;
use self::tile::{HazardKind, KeepKind, RoofKind, Tile, TileGrid, TileKind, TILE_SIZE};
pub use self::{
gen::{aabr_with_z, Fill, Painter, Primitive, PrimitiveRef, Structure},
gen::{aabr_with_z, render_collect, Fill, Filler, FillFn, Painter, Primitive, PrimitiveTransform, Structure},
plot::{Plot, PlotKind},
util::Dir,
};
@ -22,7 +22,7 @@ use common::{
terrain::{Block, BlockKind, SpriteKind, TerrainChunkSize},
vol::RectVolSize,
};
use hashbrown::hash_map::DefaultHashBuilder;
use hashbrown::{hash_map::DefaultHashBuilder, HashMap};
use rand::prelude::*;
use rand_chacha::ChaChaRng;
use std::ops::Range;
@ -386,6 +386,34 @@ impl Site {
site
}
pub fn generate_citadel(land: &Land, rng: &mut impl Rng, origin: Vec2<i32>) -> Self {
let mut rng = reseed(rng);
let mut site = Site {
origin,
..Site::default()
};
site.demarcate_obstacles(land);
let citadel = plot::Citadel::generate(origin, land, &mut rng);
site.name = citadel.name().to_string();
let size = citadel.radius() / tile::TILE_SIZE as i32;
let aabr = Aabr {
min: Vec2::broadcast(-size),
max: Vec2::broadcast(size),
};
let plot = site.create_plot(Plot {
kind: PlotKind::Citadel(citadel),
root_tile: aabr.center(),
tiles: aabr_tiles(aabr).collect(),
seed: rng.gen(),
});
site.blit_aabr(aabr, Tile {
kind: TileKind::Building,
plot: Some(plot),
hard_alt: None,
});
site
}
pub fn generate_gnarling(land: &Land, rng: &mut impl Rng, origin: Vec2<i32>) -> Self {
let mut rng = reseed(rng);
let mut site = Site {
@ -451,7 +479,7 @@ impl Site {
..Site::default()
};
site.demarcate_obstacles(land);
// site.demarcate_obstacles(land);
site.make_plaza(land, &mut rng);
@ -866,7 +894,7 @@ impl Site {
}
}
pub fn render(&self, canvas: &mut Canvas, dynamic_rng: &mut impl Rng) {
pub fn render<'a>(&'a self, canvas: &mut Canvas<'a>, arena: &mut bumpalo::Bump, dynamic_rng: &mut impl Rng) {
canvas.foreach_col(|canvas, wpos2d, col| {
let tpos = self.wpos_tile_pos(wpos2d);
@ -1029,34 +1057,59 @@ impl Site {
let info = canvas.info();
for plot in plots_to_render {
let (prim_tree, fills, mut entities) = match &self.plots[plot].kind {
PlotKind::House(house) => house.render_collect(self, canvas),
PlotKind::Workshop(workshop) => workshop.render_collect(self, canvas),
PlotKind::Castle(castle) => castle.render_collect(self, canvas),
PlotKind::Dungeon(dungeon) => dungeon.render_collect(self, canvas),
PlotKind::Gnarling(gnarling) => gnarling.render_collect(self, canvas),
PlotKind::GiantTree(giant_tree) => giant_tree.render_collect(self, canvas),
PlotKind::CliffTower(cliff_tower) => cliff_tower.render_collect(self, canvas),
common_base::prof_span!(guard, "site2::Site::render::plot_rendering");
let structure: &dyn Structure</*'a, */Canvas<'a>> = match &self.plots[plot].kind {
PlotKind::House(house) => house,
PlotKind::Workshop(workshop) => workshop,
PlotKind::Castle(castle) => castle,
PlotKind::Dungeon(dungeon) => dungeon,
PlotKind::Gnarling(gnarling) => gnarling,
PlotKind::GiantTree(giant_tree) => giant_tree,
PlotKind::CliffTower(cliff_tower) => cliff_tower,
PlotKind::Citadel(citadel) => citadel,
_ => continue,
};
drop(guard);
let mut spawn = |pos, last_block| {
/* let (prim_tree, fills, mut entities) = structure.render_collect(self, canvas); */
common_base::prof_span!("site2::Site::render::plot_rasterization");
/* let mut bounds_cache = HashMap::default(); */
/* let arena = canvas.arena; */
let render_area = Aabr {
min: canvas.wpos,
max: canvas.wpos + TerrainChunkSize::RECT_SIZE.map(|e| e as i32),
};
/* let mut entities = */structure.render_collect(
self,
arena,
info,
render_area,
/*|canvas| */canvas,
);
// NOTE: Clearing out the primitives between renders costs us nothing, because any
// chunks that get deallocated were going to be eventually deallocated anyway, while
// the current chunk remains for reuse. So this just ends up saving memory.
arena.reset();
/* let mut spawn = |pos, last_block| {
if let Some(entity) = match &self.plots[plot].kind {
PlotKind::GiantTree(tree) => tree.entity_at(pos, &last_block, dynamic_rng),
_ => None,
} {
entities.push(entity);
canvas.spawn(entity);
}
};
}; */
for (prim, fill) in fills {
for mut aabb in Fill::get_bounds_disjoint(&prim_tree, prim) {
/* for (prim, fill) in fills {
/*Fill::get_bounds_disjoint*/fill.sample_at(arena, &mut bounds_cache, &prim_tree, prim, chunk_aabr, &info, /* |pos| {
/* for mut aabb in Fill::get_bounds_disjoint(&mut bounds_cache, &prim_tree, prim) {
aabb.min = Vec2::max(aabb.min.xy(), chunk_aabr.min).with_z(aabb.min.z);
aabb.max = Vec2::min(aabb.max.xy(), chunk_aabr.max).with_z(aabb.max.z);
for x in aabb.min.x..aabb.max.x {
for y in aabb.min.y..aabb.max.y {
let col_tile = self.wpos_tile(Vec2::new(x, y));
/* let col_tile = self.wpos_tile(Vec2::new(x, y));
if
/* col_tile.is_building() && */
col_tile
@ -1066,32 +1119,40 @@ impl Site {
.map_or(false, |(a, b)| a.end > b.end)
{
continue;
}
} */
let mut last_block = None;
for z in aabb.min.z..aabb.max.z {
let pos = Vec3::new(x, y, z);
let pos = Vec3::new(x, y, z); */
canvas.map(pos, |block| {
let current_block =
fill.sample_at(&prim_tree, prim, pos, &info, block);
if let (Some(last_block), None) = (last_block, current_block) {
fill.sample_at(
/* &mut bounds_cache,
&prim_tree,
prim, */
pos,
&info,
block,
);
/* if let (Some(last_block), None) = (last_block, current_block) {
spawn(pos, last_block);
}
last_block = current_block;
last_block = current_block; */
current_block.unwrap_or(block)
});
}
/* }
if let Some(block) = last_block {
spawn(Vec3::new(x, y, aabb.max.z), block);
}
}
}
}
}
}*/
}*/canvas);
} */
for entity in entities {
/* for entity in entities {
canvas.spawn(entity);
}
} */
}
}

5
world/src/site2/plot.rs
View File

@ -1,4 +1,5 @@
mod castle;
mod citadel;
mod cliff_tower;
pub mod dungeon;
mod giant_tree;
@ -7,7 +8,8 @@ mod house;
mod workshop;
pub use self::{
castle::Castle, cliff_tower::CliffTower, dungeon::Dungeon, giant_tree::GiantTree,
castle::Castle, citadel::Citadel, cliff_tower::CliffTower,
dungeon::Dungeon, giant_tree::GiantTree,
gnarling::GnarlingFortification, house::House, workshop::Workshop,
};
@ -53,5 +55,6 @@ pub enum PlotKind {
Dungeon(Dungeon),
Gnarling(GnarlingFortification),
GiantTree(GiantTree),
Citadel(Citadel),
CliffTower(CliffTower),
}

181
world/src/site2/plot/castle.rs
View File

@ -41,8 +41,8 @@ impl Castle {
}
}
impl Structure for Castle {
fn render(&self, site: &Site, _land: &Land, painter: &Painter) {
impl<F: Filler> Structure<F> for Castle {
fn render<'a>(&self, site: &Site, _land: Land, painter: &Painter<'a>, filler: &mut FillFn<'a, '_, F>) {
let wall_height = 24;
let parapet_height = 2;
let parapet_gap = 2;
@ -55,20 +55,22 @@ impl Structure for Castle {
let wall_rgb = Rgb::new(38, 46, 43);
// Flatten inside of the castle
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: site.tile_wpos(self.tile_aabr.min).with_z(self.gate_alt),
max: site
.tile_wpos(self.tile_aabr.max)
.with_z(self.alt + tower_height),
})),
Fill::Block(Block::empty()),
}),
filler.block(Block::empty()),
filler,
);
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: site.tile_wpos(self.tile_aabr.min).with_z(self.gate_alt),
max: site.tile_wpos(self.tile_aabr.max).with_z(self.gate_alt + 1),
})),
Fill::Block(Block::new(BlockKind::Rock, Rgb::new(55, 45, 65))),
}),
filler.block(Block::new(BlockKind::Rock, Rgb::new(55, 45, 65))),
filler,
);
for x in 0..self.tile_aabr.size().w {
for y in 0..self.tile_aabr.size().h {
@ -77,93 +79,95 @@ impl Structure for Castle {
match site.tiles.get(tile_pos).kind.clone() {
TileKind::Wall(ori) => {
let dir = ori.to_vec2();
let wall = painter.prim(Primitive::Aabb(Aabb {
let wall = painter.aabb(Aabb {
min: wpos.with_z(self.alt - 20),
max: (wpos + ts).with_z(self.alt + wall_height),
}));
});
// TODO Figure out logic to choose on on which site wall should be placed
// (inner, outer)
let parapet = painter.prim(Primitive::Aabb(Aabb {
let parapet = painter.aabb(Aabb {
min: (wpos - dir.yx()).with_z(self.alt + wall_height),
max: (wpos + ts * dir).with_z(self.alt + wall_height + parapet_height),
}));
let parapet2 = painter.prim(Primitive::Aabb(Aabb {
});
let parapet2 = painter.aabb(Aabb {
min: (wpos + ts * dir.yx()).with_z(self.alt + wall_height),
max: (wpos + (ts + 1) * dir.yx() + ts * dir)
.with_z(self.alt + wall_height + parapet_height),
}));
let cut_sides = painter.prim(Primitive::Aabb(Aabb {
});
let cut_sides = painter.aabb(Aabb {
min: (wpos + parapet_offset * dir - dir.yx())
.with_z(self.alt + wall_height + parapet_height - 1),
max: (wpos
+ (ts + 1) * dir.yx()
+ (parapet_offset + parapet_gap) * dir)
.with_z(self.alt + wall_height + parapet_height),
}));
});
painter.fill(wall, Fill::Brick(BlockKind::Rock, wall_rgb, 12));
let sides = painter.prim(Primitive::union(parapet, parapet2));
painter.fill(sides, Fill::Brick(BlockKind::Rock, wall_rgb, 12));
painter.fill(wall, filler.brick(BlockKind::Rock, wall_rgb, 12), filler);
let sides = parapet.union(parapet2);
painter.fill(sides, filler.brick(BlockKind::Rock, wall_rgb, 12), filler);
if (x + y).is_odd() {
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: (wpos + 2 * dir - dir.yx()).with_z(self.alt - 20),
max: (wpos + 4 * dir + (ts + 1) * dir.yx())
.with_z(self.alt + wall_height),
})),
Fill::Brick(BlockKind::Rock, wall_rgb, 12),
}),
filler.brick(BlockKind::Rock, wall_rgb, 12),
filler,
);
} else {
let window_top = painter.prim(Primitive::Aabb(Aabb {
let window_top = painter.aabb(Aabb {
min: (wpos + 2 * dir).with_z(self.alt + wall_height / 4 + 9),
max: (wpos + (ts - 2) * dir + dir.yx())
.with_z(self.alt + wall_height / 4 + 12),
}));
let window_bottom = painter.prim(Primitive::Aabb(Aabb {
});
let window_bottom = painter.aabb(Aabb {
min: (wpos + 1 * dir).with_z(self.alt + wall_height / 4),
max: (wpos + (ts - 1) * dir + dir.yx())
.with_z(self.alt + wall_height / 4 + 9),
}));
let window_top2 = painter.prim(Primitive::Aabb(Aabb {
});
let window_top2 = painter.aabb(Aabb {
min: (wpos + 2 * dir + (ts - 1) * dir.yx())
.with_z(self.alt + wall_height / 4 + 9),
max: (wpos + (ts - 2) * dir + ts * dir.yx())
.with_z(self.alt + wall_height / 4 + 12),
}));
let window_bottom2 = painter.prim(Primitive::Aabb(Aabb {
});
let window_bottom2 = painter.aabb(Aabb {
min: (wpos + 1 * dir + (ts - 1) * dir.yx())
.with_z(self.alt + wall_height / 4),
max: (wpos + (ts - 1) * dir + ts * dir.yx())
.with_z(self.alt + wall_height / 4 + 9),
}));
});
painter.fill(window_bottom, Fill::Block(Block::empty()));
painter.fill(window_top, Fill::Block(Block::empty()));
painter.fill(window_bottom2, Fill::Block(Block::empty()));
painter.fill(window_top2, Fill::Block(Block::empty()));
painter.fill(window_bottom, filler.block(Block::empty()), filler);
painter.fill(window_top, filler.block(Block::empty()), filler);
painter.fill(window_bottom2, filler.block(Block::empty()), filler);
painter.fill(window_top2, filler.block(Block::empty()), filler);
}
painter.fill(cut_sides, Fill::Block(Block::empty()));
painter.fill(cut_sides, filler.block(Block::empty()), filler);
},
TileKind::Tower(roof) => {
let tower_total_height =
self.alt + wall_height + parapet_height + tower_height;
let tower_lower = painter.prim(Primitive::Aabb(Aabb {
let tower_lower = painter.aabb(Aabb {
min: (wpos - 1).with_z(self.alt - 20),
max: (wpos + ts + 1).with_z(tower_total_height),
}));
painter.fill(tower_lower, Fill::Brick(BlockKind::Rock, wall_rgb, 12));
let tower_upper = painter.prim(Primitive::Aabb(Aabb {
});
painter.fill(tower_lower, filler.brick(BlockKind::Rock, wall_rgb, 12), filler);
let tower_upper = painter.aabb(Aabb {
min: (wpos - 2).with_z(tower_total_height - 4i32),
max: (wpos + ts + 2).with_z(tower_total_height - 2i32),
}));
let tower_upper2 = painter.prim(Primitive::Aabb(Aabb {
});
let tower_upper2 = painter.aabb(Aabb {
min: (wpos - 3).with_z(tower_total_height - 2i32),
max: (wpos + ts + 3).with_z(tower_total_height),
}));
});
painter.fill(
painter.prim(Primitive::union(tower_upper, tower_upper2)),
Fill::Brick(BlockKind::Rock, wall_rgb, 12),
tower_upper.union(tower_upper2),
filler.brick(BlockKind::Rock, wall_rgb, 12),
filler,
);
match roof {
@ -172,60 +176,63 @@ impl Structure for Castle {
let roof_height = (ts + 3) / 2 + roof_lip + 1;
painter.fill(
painter.prim(Primitive::Pyramid {
aabb: Aabb {
painter.pyramid(
Aabb {
min: (wpos - 3 - roof_lip).with_z(tower_total_height),
max: (wpos + ts + 3 + roof_lip)
.with_z(tower_total_height + roof_height),
},
inset: roof_height,
}),
Fill::Brick(BlockKind::Wood, Rgb::new(40, 5, 11), 10),
// roof_height,
),
filler.brick(BlockKind::Wood, Rgb::new(40, 5, 11), 10),
filler,
);
},
RoofKind::Parapet => {
let tower_top_outer = painter.prim(Primitive::Aabb(Aabb {
let tower_top_outer = painter.aabb(Aabb {
min: (wpos - 3).with_z(
self.alt + wall_height + parapet_height + tower_height,
),
max: (wpos + ts + 3)
.with_z(tower_total_height + parapet_height),
}));
let tower_top_inner = painter.prim(Primitive::Aabb(Aabb {
});
let tower_top_inner = painter.aabb(Aabb {
min: (wpos - 2).with_z(tower_total_height),
max: (wpos + ts + 2)
.with_z(tower_total_height + parapet_height),
}));
});
tower_top_outer
.union(tower_top_inner)
.without(tower_top_outer.intersect(tower_top_inner))
.fill(Fill::Brick(BlockKind::Rock, wall_rgb, 12));
.fill(filler.brick(BlockKind::Rock, wall_rgb, 12), filler);
for x in (wpos.x..wpos.x + ts).step_by(2 * parapet_gap as usize) {
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: Vec3::new(x, wpos.y - 3, tower_total_height + 1),
max: Vec3::new(
x + parapet_gap,
wpos.y + ts + 3,
tower_total_height + parapet_height,
),
})),
Fill::Block(Block::empty()),
}),
filler.block(Block::empty()),
filler,
);
}
for y in (wpos.y..wpos.y + ts).step_by(2 * parapet_gap as usize) {
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: Vec3::new(wpos.x - 3, y, tower_total_height + 1),
max: Vec3::new(
wpos.x + ts + 3,
y + parapet_gap,
tower_total_height + parapet_height,
),
})),
Fill::Block(Block::empty()),
}),
filler.block(Block::empty()),
filler,
);
}
@ -233,19 +240,21 @@ impl Structure for Castle {
let pos = wpos - 3 + (ts + 6) * cpos - cpos;
let pos2 = wpos - 2 + (ts + 4) * cpos - cpos;
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: pos.with_z(tower_total_height - 2),
max: (pos + 1)
.with_z(tower_total_height + parapet_height),
})),
Fill::Block(Block::empty()),
}),
filler.block(Block::empty()),
filler,
);
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: pos2.with_z(tower_total_height - 4),
max: (pos2 + 1).with_z(tower_total_height - 2),
})),
Fill::Block(Block::empty()),
}),
filler.block(Block::empty()),
filler,
);
}
},
@ -257,14 +266,15 @@ impl Structure for Castle {
for i in 0..keep_levels + 1 {
let height = keep_level_height * i;
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: wpos.with_z(self.alt + height),
max: (wpos + ts).with_z(self.alt + height + 1),
})),
Fill::Block(Block::new(
}),
filler.block(Block::new(
BlockKind::Wood,
Rgb::new(89, 44, 14),
)),
filler,
);
}
},
@ -291,47 +301,52 @@ impl Structure for Castle {
.with_z(self.alt + wall_height),
};
painter.fill(
painter.prim(Primitive::Aabb(gate_aabb)),
Fill::Brick(BlockKind::Rock, wall_rgb, 12),
painter.aabb(gate_aabb),
filler.brick(BlockKind::Rock, wall_rgb, 12),
filler,
);
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: (gate_aabb.min + Vec3::unit_x() * 2 + Vec3::unit_z() * 2),
max: (gate_aabb.max - Vec3::unit_x() * 2 - Vec3::unit_z() * 16),
})),
Fill::Block(Block::empty()),
}),
filler.block(Block::empty()),
filler,
);
let height = self.alt + wall_height - 17;
for i in 1..5 {
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: Vec3::new(gate_aabb.min.x + 2 + i, gate_aabb.min.y, height + i as i32),
max: Vec3::new(
gate_aabb.max.x - 2 - i,
gate_aabb.max.y,
height + i as i32 + 1,
),
})),
Fill::Block(Block::empty()),
}),
filler.block(Block::empty()),
filler,
);
}
let height = self.alt + wall_height - 7;
for x in (gate_aabb.min.x + 1..gate_aabb.max.x - 2).step_by(4) {
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: Vec3::new(x, gate_aabb.min.y + 1, height - 13),
max: Vec3::new(x + 2, gate_aabb.min.y + 2, height),
})),
Fill::Brick(BlockKind::Rock, Rgb::new(27, 35, 32), 8),
}),
filler.brick(BlockKind::Rock, Rgb::new(27, 35, 32), 8),
filler,
);
}
for z in (height - 12..height).step_by(4) {
painter.fill(
painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: Vec3::new(gate_aabb.min.x + 2, gate_aabb.min.y + 1, z),
max: Vec3::new(gate_aabb.max.x - 2, gate_aabb.min.y + 2, z + 2),
})),
Fill::Brick(BlockKind::Rock, Rgb::new(27, 35, 32), 8),
}),
filler.brick(BlockKind::Rock, Rgb::new(27, 35, 32), 8),
filler,
);
}
}

178
world/src/site2/plot/citadel.rs Normal file
View File

@ -0,0 +1,178 @@
use super::*;
use crate::{
assets::AssetHandle,
site2::util::Dir,
util::{attempt, sampler::Sampler, RandomField, NEIGHBORS},
Land,
};
use common::{
generation::{ChunkSupplement, EntityInfo},
terrain::{Structure as PrefabStructure, StructuresGroup},
};
use kiddo::{distance::squared_euclidean, KdTree};
use lazy_static::lazy_static;
use rand::prelude::*;
use std::ops::{Add, Div, Mul};
use vek::*;
struct Cell {
alt: i32,
colonade: Option<i32>,
}
const CELL_SIZE: i32 = 16;
pub struct Citadel {
name: String,
seed: u32,
origin: Vec3<i32>,
radius: i32,
grid: Grid<Option<Cell>>,
}
impl Citadel {
pub fn generate(wpos: Vec2<i32>, land: &Land, rng: &mut impl Rng) -> Self {
let alt = land.get_alt_approx(wpos) as i32;
let name = NameGen::location(rng).generate_town();
let seed = rng.gen();
let origin = wpos.with_z(alt);
let radius = 150;
let cell_radius = radius / CELL_SIZE;
let mut grid = Grid::populate_from(Vec2::broadcast((cell_radius + 1) * 2), |pos| {
let rpos = pos - cell_radius;
if rpos.magnitude_squared() < cell_radius.pow(2) {
let height = Lerp::lerp(
120.0,
24.0,
rpos.map(i32::abs).reduce_max() as f32 / cell_radius as f32,
);
let level_height = 32.0;
Some(Cell {
alt: land
.get_alt_approx(wpos + rpos * CELL_SIZE + CELL_SIZE / 2)
.add(height)
.div(level_height)
.floor()
.mul(level_height) as i32,
colonade: None,
})
} else {
None
}
});
for y in 0..grid.size().y {
for x in 0..grid.size().x {
let pos = Vec2::new(x, y);
if let Some(min_alt) = NEIGHBORS
.into_iter()
.filter_map(|rpos| Some(grid.get(pos + rpos)?.as_ref()?.alt))
.min()
{
let Some(Some(cell)) = grid.get_mut(pos)
else { continue };
if min_alt < cell.alt {
cell.colonade = Some(min_alt);
}
}
}
}
Self {
name,
seed,
origin,
radius,
grid,
}
}
pub fn name(&self) -> &str { &self.name }
pub fn radius(&self) -> i32 { self.radius }
pub fn spawn_rules(&self, wpos: Vec2<i32>) -> SpawnRules {
SpawnRules {
trees: (wpos - self.origin).map(i32::abs).reduce_max() > self.radius,
waypoints: false,
..SpawnRules::default()
}
}
fn wpos_cell(&self, wpos: Vec2<i32>) -> Vec2<i32> {
(wpos - self.origin) / CELL_SIZE + self.grid.size() / 2
}
fn cell_wpos(&self, pos: Vec2<i32>) -> Vec2<i32> {
(pos - self.grid.size() / 2) * CELL_SIZE + self.origin
}
}
impl<F: Filler> Structure<F> for Citadel {
fn render<'a>(&self, _site: &Site, land: Land, painter: &Painter<'a>, filler: &mut FillFn<'a, '_, F>) {
let brick = filler.brick(BlockKind::Rock, Rgb::new(100, 100, 100), 20);
for (pos, cell) in self.grid.iter_area(
self.wpos_cell(filler.render_aabr().min) - 1,
Vec2::<i32>::from(filler.render_aabr().size()) / CELL_SIZE + 2,
) {
if let Some(cell) = cell {
let wpos = self.cell_wpos(pos);
// Clear space above
painter
.aabb(Aabb {
min: wpos.with_z(cell.alt),
max: (wpos + CELL_SIZE).with_z(cell.alt + 16),
})
.clear(filler);
let /*mut */prim = painter.aabb(Aabb {
min: wpos.with_z(land.get_alt_approx(wpos + CELL_SIZE / 2) as i32 - 32),
max: (wpos + CELL_SIZE).with_z(cell.alt),
})/*.as_kind()*/;
prim.fill(brick, filler);
// Walls around cells
for dir in CARDINALS {
if self
.grid
.get(pos + dir)
.and_then(Option::as_ref)
.map_or(true, |near| near.alt < cell.alt)
{
let offset = wpos + CELL_SIZE / 2 + dir * CELL_SIZE / 2;
let rad = dir.map(|e| if e == 0 { CELL_SIZE / 2 + 1 } else { 1 });
let height = if pos.sum() % 2 == 0 { 5 } else { 2 };
/*prim = prim.union(*/painter.aabb(Aabb {
min: (offset - rad).with_z(cell.alt - 6),
max: (offset + rad).with_z(cell.alt + height),
})./*as_kind()*/fill(brick, filler);
}
}
// prim.fill(filler.brick(BlockKind::Rock, Rgb::new(100, 100, 100), 20), filler);
// Colonades under cells
if let Some(colonade_alt) = cell.colonade {
let hole = painter
.aabb(Aabb {
min: wpos.with_z(colonade_alt),
max: (wpos + CELL_SIZE).with_z(cell.alt),
})
.as_kind()
.intersect(painter.superquadric(
Aabb {
min: (wpos - 1).with_z(colonade_alt - 32),
max: (wpos + 1 + CELL_SIZE).with_z(cell.alt - 1),
},
2.5,
));
hole.clear(filler);
/* prim = /*prim.without(hole)*/hole; */
}
}
}
}
}

389
world/src/site2/plot/cliff_tower.rs
View File

@ -8,7 +8,7 @@ use common::{
terrain::{BlockKind, SpriteKind},
};
use rand::prelude::*;
use std::{mem, sync::Arc};
use std::mem;
use vek::*;
/// Represents house data generated by the `generate()` method
@ -39,8 +39,8 @@ impl CliffTower {
}
}
impl Structure for CliffTower {
fn render(&self, _site: &Site, _land: &Land, painter: &Painter) {
impl<F: Filler> Structure<F> for CliffTower {
fn render<'a>(&self, _site: &Site, _land: Land, painter: &Painter<'a>, filler: &mut FillFn<'a, '_, F>) {
let base = self.alt + 1;
let center = self.bounds.center();
let variant_pos = center.with_z(base);
@ -53,9 +53,11 @@ impl Structure for CliffTower {
let mut height = 18 + variant / 2;
let (mut stair_pos1, mut stair_pos2) = (center - 3, center + 3);
let mut floor_level = base - 40;
let brick = Fill::Sampling(Arc::new(|variant_pos| {
Some(
match (RandomField::new(0).get(Vec3::new(variant_pos.z, 0, 0))) % 15 {
fn brick_fill<'a>(arena: &'a bumpalo::Bump, range: Range<i32>) -> impl Fn(Vec3<i32>) -> Option<Block> + 'a {
// Precompute bricks for each height level.
let start = range.start;
let bricks = &*arena.alloc_slice_fill_iter(/*(0..x_bounds)*/range.map(|z| {
match (RandomField::new(0).get(Vec3::new(z, 0, 0))) % 15 {
0 => Block::new(BlockKind::Rock, Rgb::new(51, 89, 118)),
1 => Block::new(BlockKind::Rock, Rgb::new(57, 96, 126)),
2 => Block::new(BlockKind::Rock, Rgb::new(59, 103, 136)),
@ -71,21 +73,54 @@ impl Structure for CliffTower {
12 => Block::new(BlockKind::Rock, Rgb::new(52, 63, 72)),
13 => Block::new(BlockKind::Rock, Rgb::new(74, 128, 168)),
_ => Block::new(BlockKind::Rock, Rgb::new(69, 123, 162)),
},
)
}));
let wood = Fill::Brick(BlockKind::Wood, Rgb::new(106, 83, 51), 12);
let color = Fill::Block(Block::air(SpriteKind::CliffDecorBlock));
let window = Fill::Block(Block::air(SpriteKind::WindowArabic));
let window2 = Fill::Block(Block::air(SpriteKind::WindowArabic).with_ori(2).unwrap());
}
}));
// move |pos| bricks.get((pos.z - start) as usize).copied()
move |pos| (pos.z - start).try_into().ok().and_then(|z: usize| bricks.get(z).copied())
}
let brick_fill = brick_fill(painter.arena, floor_level..floor_level + (storeys + 1) * height);
/* let brick_fill = &*painter.arena.alloc_with(move || brick_fill); */
let brick = /*Fill::Sampling*/filler.sampling(&brick_fill);
let wood = filler.brick(BlockKind::Wood, Rgb::new(106, 83, 51), 12);
let color = filler.block(Block::air(SpriteKind::CliffDecorBlock));
let window = filler.block(Block::air(SpriteKind::WindowArabic));
let window2 = filler.block(Block::air(SpriteKind::WindowArabic).with_ori(2).unwrap());
for s in 0..storeys {
let old_x_offset = RandomField::new(0).get((center - (width+1)).with_z(base)) as i32 % 10;
let old_y_offset = RandomField::new(0).get((center + (width+1)).with_z(base)) as i32 % 10;
let old_super_center = Vec2::new(center.x - 3 + old_x_offset / 2, center.y - 3 + old_y_offset / 2);
let x_offset = RandomField::new(0).get((center - length).with_z(base)) as i32 % 10;
let y_offset = RandomField::new(0).get((center + length).with_z(base)) as i32 % 10;
let super_center = Vec2::new(center.x - 3 + x_offset / 2, center.y - 3 + y_offset / 2);
let room1_type = RandomField::new(0).get((center - length).with_z(base)) as i32 % 2;
let room2_type = RandomField::new(0).get((center - length - 1).with_z(base)) as i32 % 2;
// CliffTower Hoodoo Overlay
painter
let min_super_center = Vec2::<i32>::partial_min(old_super_center, super_center);
let max_super_center = Vec2::<i32>::partial_max(old_super_center, super_center);
let max_length = length.max(width);
/*if s + 1 != storeys */{
/*painter
.aabb(Aabb {
min: (min_super_center - max_length + 2).with_z(floor_level - height / 2),
max: (max_super_center + max_length + 1).with_z(floor_level + max_length.min(height / 2)),
}).as_kind()
.intersect*/(
painter.line_two_radius(
old_super_center.with_z(floor_level - height),
super_center.with_z(floor_level),
(width - 2) as f32,
(length - 1) as f32,
1.0,
)
)
.fill(brick, filler);
}
/* painter
.cubic_bezier(
super_center.with_z(floor_level + (height / 2)),
(super_center - x_offset).with_z(floor_level + height),
@ -93,7 +128,47 @@ impl Structure for CliffTower {
super_center.with_z(floor_level + (2 * height)),
(length - 1) as f32,
)
.fill(brick.clone());
.fill(brick); */
/* let diverge = ((x_offset * x_offset + y_offset * y_offset) as f32).sqrt(); */
/* painter.aabb(Aabb {
min: Vec2::new(super_center.x - length + 1, super_center.y - length + 1)
.with_z(floor_level + (height / 2)),
max: Vec2::new(super_center.x + length - 1 - diverge as i32, super_center.y + length - 1 - diverge as i32)
.with_z(floor_level + (height) + (height / 4)),
}).as_kind()
.intersect(
painter.superquadric/*_sheared*/(
Aabb {
min: super_center.with_z(floor_level + (height / 2)) +
Vec3::new(-length + 1, - length + 1, /*- length + 1*/- length + 1),
max: super_center.with_z(floor_level + (height) + (height / 4)) +
Vec3::new(-/*(x_offset + y_offset) / 2*/diverge as i32 + length, -/*(x_offset + y_offset) / 2*/diverge as i32 + length, /*length*/length),
},
/*Vec2::new(/*(*/-/*(x_offset + y_offset) / 2) as f32*/diverge / (((height) + (height / 4)) as f32), -/*(x_offset + y_offset) as f32*/diverge / (((height) + (height / 4)) as f32)),*/
2.01,
)
)
.fill(brick);
painter.aabb(Aabb {
min: Vec2::new(super_center.x + length - 1 - diverge as i32, super_center.y + length - 1 - diverge as i32)
.with_z(floor_level + (height) + (height / 4)),
max: Vec2::new(super_center.x - length + 1, super_center.y - length + 1)
.with_z(floor_level + (2 * height) - (height / 4)),
}).as_kind()
.intersect(
painter.superquadric/*_sheared*/(
Aabb {
min: super_center.with_z(floor_level + (height)/* + (height / 4)*/) +
Vec3::new(-/*x_offset / 2*/diverge as i32 + length, -/*y_offset / 2*/diverge as i32 + length, /*length*/length),
max: super_center.with_z(floor_level + (2 * height) - (height / 4)) +
Vec3::new(-length + 1, - length + 1, /*- length + 1*/- length + 1),
},
/* Vec2::new(/*((x_offset + y_offset) / 2) as f32*/diverge / (((height) + (height / 2) - (height / 4)) as f32), /*((x_offset + y_offset) / 2) as f32*/diverge / (((height) + (height / 4)) as f32)), */
2.01,
)
)
.fill(brick); */
// only inhabit towers with enough storeys to have entries above ground
if storeys > 3 {
// wood or rocky platforms
@ -106,25 +181,15 @@ impl Structure for CliffTower {
painter
.superquadric(
Aabb {
min: (super_center - (5 * (length / 3)) + 3)
.with_z(floor_level),
max: (super_center + (5 * (length / 3)) - 3)
.with_z(floor_level + 2),
min: (super_center - (5 * (length / 3)) + 2)
.with_z(floor_level + 1),
max: (super_center + (5 * (length / 3)) - 1)
.with_z(floor_level + 5),
},
6.0,
)
.fill(wood.clone());
painter
.prim(Primitive::without(
painter.superquadric(
Aabb {
min: (super_center - (5 * (length / 3)) + 2)
.with_z(floor_level + 1),
max: (super_center + (5 * (length / 3)) - 1)
.with_z(floor_level + 5),
},
6.0,
),
.fill(wood, filler);
/*.without(*/
painter.superquadric(
Aabb {
min: (super_center - (5 * (length / 3)) + 2)
@ -133,9 +198,21 @@ impl Structure for CliffTower {
.with_z(floor_level + 5),
},
6.0,
),
))
.fill(wood.clone());
)/*,
)
.fill(wood);*/
.clear(filler);
painter
.superquadric(
Aabb {
min: (super_center - (5 * (length / 3)) + 3)
.with_z(floor_level),
max: (super_center + (5 * (length / 3)) - 3)
.with_z(floor_level + 2),
},
6.0,
)
.fill(wood, filler);
// lanterns & random sprites for wood platform corners
for dir in SQUARE_4 {
let corner_pos = super_center - (5 * (length / 4));
@ -151,6 +228,7 @@ impl Structure for CliffTower {
5 => SpriteKind::Pot,
_ => SpriteKind::Lantern,
},
filler,
);
}
// planters for larger wood platforms
@ -173,11 +251,12 @@ impl Structure for CliffTower {
)
.with_z(floor_level + 6),
})
.clear();
.clear(filler);
painter.rotated_sprite(
planter_pos.with_z(floor_level + 4),
SpriteKind::Planter,
(4 - (r * 4)) as u8,
filler,
);
}
}
@ -187,30 +266,32 @@ impl Structure for CliffTower {
painter
.superquadric(
Aabb {
min: (center - length + 1).with_z(floor_level),
max: (center + length - 1).with_z(floor_level + 2),
min: (center - length).with_z(floor_level + 1),
max: (center + length).with_z(floor_level + 5),
},
sq_type,
)
.fill(brick.clone());
painter
.prim(Primitive::without(
painter.superquadric(
Aabb {
min: (center - length).with_z(floor_level + 1),
max: (center + length).with_z(floor_level + 5),
},
sq_type,
),
.fill(brick, filler);
/*.without(*/
painter.superquadric(
Aabb {
min: (center - length + 3).with_z(floor_level + 3),
max: (center + length - 3).with_z(floor_level + 5),
},
sq_type,
),
))
.fill(brick.clone());
)/*,
)
.fill(brick)*/
.clear(filler);
painter
.superquadric(
Aabb {
min: (center - length + 1).with_z(floor_level),
max: (center + length - 1).with_z(floor_level + 2),
},
sq_type,
)
.fill(brick, filler);
},
}
}
@ -225,33 +306,42 @@ impl Structure for CliffTower {
},
sq_type,
)
.fill(brick.clone());
.fill(brick, filler);
// clear room - leave some floor
painter.aabb(Aabb {
min: Vec2::new(super_center.x - length + 1, super_center.y + 1 - width)
.with_z(floor_level + 4),
max: Vec2::new(super_center.x + length - 1, super_center.y - 1 + width)
.with_z(floor_level + height - 1),
}).as_kind()
.intersect(
painter
.prim(Primitive::without(
painter.superquadric(
Aabb {
min: Vec2::new(
super_center.x - length + 1,
super_center.y + 1 - width,
)
.with_z(floor_level + 1),
max: Vec2::new(
super_center.x + length - 1,
super_center.y - 1 + width,
)
.with_z(floor_level + height - 1),
},
sq_type,
),
.superquadric(
Aabb {
min: Vec2::new(
super_center.x - length + 1,
super_center.y + 1 - width,
)
.with_z(floor_level + 1),
max: Vec2::new(
super_center.x + length - 1,
super_center.y - 1 + width,
)
.with_z(floor_level + height - 1),
},
sq_type,
)
/* .clear(filler); */
/* .without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x - length + 1, super_center.y + 1 - width)
.with_z(floor_level + 1),
max: Vec2::new(super_center.x + length - 1, super_center.y - 1 + width)
.with_z(floor_level + 4),
}),
))
.clear();
}).as_kind(),
) */
)
.clear(filler);
// entries
painter
.aabb(Aabb {
@ -260,7 +350,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x - length + 6, super_center.y + 2)
.with_z(floor_level + 4),
})
.fill(brick.clone());
.fill(brick, filler);
painter
.aabb(Aabb {
min: Vec2::new(super_center.x + length - 6, super_center.y - 2)
@ -268,7 +358,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + length, super_center.y + 2)
.with_z(floor_level + 4),
})
.fill(brick.clone());
.fill(brick, filler);
// colored sills
painter
.aabb(Aabb {
@ -277,7 +367,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x - length, super_center.y + 2)
.with_z(floor_level + 4),
})
.fill(color.clone());
.fill(color, filler);
painter
.aabb(Aabb {
min: Vec2::new(super_center.x + length, super_center.y - 2)
@ -285,7 +375,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + length + 1, super_center.y + 2)
.with_z(floor_level + 4),
})
.fill(color.clone());
.fill(color, filler);
if floor_level > base {
// clear entries
painter
@ -295,40 +385,39 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + length + 12, super_center.y + 2)
.with_z(floor_level + 7),
})
.clear();
.clear(filler);
// door sprites
painter
.prim(Primitive::without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x - length + 1, super_center.y - 2)
.with_z(floor_level + 4),
max: Vec2::new(super_center.x - length + 2, super_center.y + 2)
.with_z(floor_level + 7),
}),
.aabb(Aabb {
min: Vec2::new(super_center.x - length + 1, super_center.y - 2)
.with_z(floor_level + 4),
max: Vec2::new(super_center.x - length + 2, super_center.y + 2)
.with_z(floor_level + 7),
})
.without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x - length + 1, super_center.y - 1)
.with_z(floor_level + 4),
max: Vec2::new(super_center.x - length + 2, super_center.y + 1)
.with_z(floor_level + 7),
}),
))
.fill(window.clone());
painter
.prim(Primitive::without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x + length - 1, super_center.y - 2)
.with_z(floor_level + 4),
max: Vec2::new(super_center.x + length, super_center.y + 2)
.with_z(floor_level + 7),
}),
)
.fill(window, filler);
painter.aabb(Aabb {
min: Vec2::new(super_center.x + length - 1, super_center.y - 2)
.with_z(floor_level + 4),
max: Vec2::new(super_center.x + length, super_center.y + 2)
.with_z(floor_level + 7),
})
.without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x + length - 1, super_center.y - 1)
.with_z(floor_level + 4),
max: Vec2::new(super_center.x + length, super_center.y + 1)
.with_z(floor_level + 7),
}),
))
.fill(window.clone());
)
.fill(window, filler);
// windows
painter
.aabb(Aabb {
@ -337,7 +426,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + 4, super_center.y - width + 3)
.with_z(floor_level + 6),
})
.fill(brick.clone());
.fill(brick, filler);
painter
.aabb(Aabb {
min: Vec2::new(super_center.x - 4, super_center.y - width + 1)
@ -345,7 +434,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + 4, super_center.y - width + 3)
.with_z(floor_level + 5),
})
.fill(brick.clone());
.fill(brick, filler);
painter
.aabb(Aabb {
min: Vec2::new(super_center.x - 4, super_center.y + width - 3)
@ -353,7 +442,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + 4, super_center.y + width + 1)
.with_z(floor_level + 6),
})
.fill(brick.clone());
.fill(brick, filler);
painter
.aabb(Aabb {
min: Vec2::new(super_center.x - 4, super_center.y + width - 3)
@ -361,7 +450,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + 4, super_center.y + width)
.with_z(floor_level + 5),
})
.fill(brick.clone());
.fill(brick, filler);
painter
.aabb(Aabb {
min: Vec2::new(super_center.x - 3, super_center.y - width - 1)
@ -369,7 +458,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + 3, super_center.y - width)
.with_z(floor_level + 6),
})
.fill(color.clone());
.fill(color, filler);
painter
.aabb(Aabb {
min: Vec2::new(super_center.x - 3, super_center.y + width + 1)
@ -377,7 +466,7 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + 3, super_center.y + width + 2)
.with_z(floor_level + 6),
})
.fill(color.clone());
.fill(color, filler);
// clear windows
painter
.aabb(Aabb {
@ -386,40 +475,40 @@ impl Structure for CliffTower {
max: Vec2::new(super_center.x + 4, super_center.y + width + 12)
.with_z(floor_level + 9),
})
.clear();
.clear(filler);
// window sprites
painter
.prim(Primitive::without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x - 4, super_center.y - width + 1)
.with_z(floor_level + 6),
max: Vec2::new(super_center.x + 4, super_center.y - width + 2)
.with_z(floor_level + 9),
}),
.aabb(Aabb {
min: Vec2::new(super_center.x - 4, super_center.y - width + 1)
.with_z(floor_level + 6),
max: Vec2::new(super_center.x + 4, super_center.y - width + 2)
.with_z(floor_level + 9),
})
.without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x - 1, super_center.y - width + 1)
.with_z(floor_level + 6),
max: Vec2::new(super_center.x + 1, super_center.y - width + 2)
.with_z(floor_level + 9),
}),
))
.fill(window2.clone());
)
.fill(window2, filler);
painter
.prim(Primitive::without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x - 4, super_center.y + width - 1)
.with_z(floor_level + 6),
max: Vec2::new(super_center.x + 4, super_center.y + width)
.with_z(floor_level + 9),
}),
.aabb(Aabb {
min: Vec2::new(super_center.x - 4, super_center.y + width - 1)
.with_z(floor_level + 6),
max: Vec2::new(super_center.x + 4, super_center.y + width)
.with_z(floor_level + 9),
})
.without(
painter.aabb(Aabb {
min: Vec2::new(super_center.x - 1, super_center.y + width - 1)
.with_z(floor_level + 6),
max: Vec2::new(super_center.x + 1, super_center.y + width)
.with_z(floor_level + 9),
}),
))
.fill(window2.clone());
)
.fill(window2, filler);
}
// room wall lamps
for d in 0..2 {
@ -432,6 +521,7 @@ impl Structure for CliffTower {
door_lamp_pos,
SpriteKind::WallLampSmall,
2 + ((d * 4) as u8),
filler,
);
let window_lamp_pos = Vec2::new(
@ -443,6 +533,7 @@ impl Structure for CliffTower {
window_lamp_pos,
SpriteKind::WallLampSmall,
4 - ((d * 4) as u8),
filler,
);
}
// furniture sprites in room1(living_room, workshop), room2(kitchen, bath)
@ -480,7 +571,7 @@ impl Structure for CliffTower {
RandomField::new(0).get(pos.with_z(base)) as usize
% liv_sprites.len(),
);
painter.sprite(pos.with_z(floor_level + 4), sprite);
painter.sprite(pos.with_z(floor_level + 4), sprite, filler);
}
}
// bookshelfs
@ -499,11 +590,12 @@ impl Structure for CliffTower {
max: Vec2::new(pos.x + 3, pos.y + 1 + (2 * d))
.with_z(floor_level + 6),
})
.clear();
.clear(filler);
painter.rotated_sprite(
pos.with_z(floor_level + 6),
SpriteKind::BookshelfArabic,
(4 * d) as u8,
filler,
);
}
}
@ -529,11 +621,12 @@ impl Structure for CliffTower {
)
.with_z(floor_level + 8),
})
.clear();
.clear(filler);
painter.rotated_sprite(
pos.with_z(floor_level + 4),
SpriteKind::CanapeArabic,
(4 * d) as u8,
filler,
);
}
}
@ -553,7 +646,7 @@ impl Structure for CliffTower {
max: Vec2::new(pos.x + 3, pos.y + 2)
.with_z(floor_level + 6),
})
.clear();
.clear(filler);
painter.sprite(
pos.with_z(floor_level + 4),
match (RandomField::new(0).get(pos.with_z(floor_level - d)))
@ -563,6 +656,7 @@ impl Structure for CliffTower {
1 => SpriteKind::DecorSetArabic,
_ => SpriteKind::SepareArabic,
},
filler,
)
};
}
@ -589,11 +683,12 @@ impl Structure for CliffTower {
)
.with_z(floor_level + 7),
})
.clear();
.clear(filler);
painter.rotated_sprite(
ft_pos.with_z(floor_level + 4),
SpriteKind::ForgeTools,
(4 * d) as u8,
filler,
);
}
// hearth
@ -611,11 +706,12 @@ impl Structure for CliffTower {
max: Vec2::new(pos.x + 3, pos.y + 5 - (4 * d))
.with_z(floor_level + 6),
})
.clear();
.clear(filler);
painter.rotated_sprite(
pos.with_z(floor_level + 4),
SpriteKind::Hearth,
(4 * d) as u8,
filler,
);
}
}
@ -636,7 +732,7 @@ impl Structure for CliffTower {
RandomField::new(0).get(pos.with_z(base)) as usize
% ws_sprites.len(),
);
painter.sprite(pos.with_z(floor_level + 4), sprite);
painter.sprite(pos.with_z(floor_level + 4), sprite, filler);
}
}
},
@ -661,11 +757,12 @@ impl Structure for CliffTower {
max: Vec2::new(pos.x + 3, pos.y + 4 - (d * 3))
.with_z(floor_level + 7),
})
.clear();
.clear(filler);
painter.rotated_sprite(
pos.with_z(floor_level + 4),
SpriteKind::WallTableArabic,
(4 * d) as u8,
filler,
);
painter.rotated_sprite(
pos.with_z(floor_level + 5),
@ -679,6 +776,7 @@ impl Structure for CliffTower {
_ => SpriteKind::JugAndBowlArabic,
},
(4 * d) as u8,
filler,
);
}
}
@ -701,7 +799,7 @@ impl Structure for CliffTower {
RandomField::new(0).get(pos.with_z(base)) as usize
% ba_sprites.len(),
);
painter.sprite(pos.with_z(floor_level + 4), sprite)
painter.sprite(pos.with_z(floor_level + 4), sprite, filler)
}
}
// fountains
@ -718,10 +816,11 @@ impl Structure for CliffTower {
min: (pos - 1).with_z(floor_level + 4),
max: (pos + 2).with_z(floor_level + 5),
})
.clear();
.clear(filler);
painter.sprite(
pos.with_z(floor_level + 4),
SpriteKind::FountainArabic,
filler,
)
};
}
@ -744,7 +843,7 @@ impl Structure for CliffTower {
max: Vec2::new(pos.x + 2, pos.y + 4)
.with_z(floor_level + 7),
})
.clear();
.clear(filler);
painter.rotated_sprite(
pos.with_z(floor_level + 4),
match (RandomField::new(0).get(pos.with_z(floor_level))) % 2
@ -753,6 +852,7 @@ impl Structure for CliffTower {
_ => SpriteKind::OvenArabic,
},
4,
filler,
);
}
}
@ -771,7 +871,7 @@ impl Structure for CliffTower {
max: Vec2::new(pos.x + 2, pos.y + 1)
.with_z(floor_level + 7),
})
.clear();
.clear(filler);
painter.rotated_sprite(
pos.with_z(floor_level + 4),
match (RandomField::new(0).get(pos.with_z(floor_level))) % 4
@ -782,6 +882,7 @@ impl Structure for CliffTower {
_ => SpriteKind::JugArabic,
},
0,
filler,
);
}
}
@ -801,11 +902,12 @@ impl Structure for CliffTower {
max: Vec2::new(pos.x + 2, pos.y + 4 - (3 * d))
.with_z(floor_level + 7),
})
.clear();
.clear(filler);
painter.rotated_sprite(
pos.with_z(floor_level + 4),
SpriteKind::WallTableArabic,
(4 * d) as u8,
filler,
);
painter.rotated_sprite(
pos.with_z(floor_level + 5),
@ -818,6 +920,7 @@ impl Structure for CliffTower {
_ => SpriteKind::VialEmpty,
},
(4 * d) as u8,
filler,
);
}
}
@ -842,7 +945,7 @@ impl Structure for CliffTower {
RandomField::new(0).get(pos.with_z(base)) as usize
% kit_sprites.len(),
);
painter.sprite(pos.with_z(floor_level + 4), sprite);
painter.sprite(pos.with_z(floor_level + 4), sprite, filler);
}
}
},
@ -856,31 +959,29 @@ impl Structure for CliffTower {
min: (stair_pos1 - 3).with_z(floor_level - height + 4),
max: (stair_pos1 + 3).with_z(floor_level + 7),
})
.clear();
.clear(filler);
//stairway
let stair_radius1 = 4.0;
let stairs_clear1 = painter.prim(Primitive::Cylinder(Aabb {
let stairs_clear1 = painter.cylinder(Aabb {
min: (stair_pos1 - stair_radius1 as i32).with_z(floor_level - height),
max: (stair_pos1 + stair_radius1 as i32).with_z(floor_level + 4),
}));
painter
.prim(Primitive::sampling(
stairs_clear1,
crate::site2::plot::dungeon::spiral_staircase(
});
let stairs_fill =
/* painter.arena.alloc_with(move || */|pos| crate::site2::plot::dungeon::spiral_staircase(
stair_pos1.with_z(floor_level + 4),
stair_radius1,
0.5,
7.0,
),
))
.fill(brick.clone());
)(pos).then(|| brick_fill(pos)).flatten()/*)*/;
stairs_clear1
.fill(/*Fill::Sampling*/filler.sampling(&stairs_fill), filler);
}
// spawn mountaineers in each room
let spawn_pos = super_center.with_z(floor_level + 4);
let npc_amount = RandomField::new(0).get(spawn_pos) % 4;
for _ in 0..npc_amount {
let mut rng = rand::thread_rng();
painter.spawn(
filler.spawn(
EntityInfo::at(spawn_pos.map(|e| e as f32))
.with_asset_expect("common.entity.village.mountaineer", &mut rng),
);

564
world/src/site2/plot/dungeon.rs
View File

@ -1,7 +1,7 @@
use super::*;
use crate::{
site::namegen::NameGen,
site2::{self, aabr_with_z, Fill, Primitive, Structure as SiteStructure},
site2::{self, aabr_with_z, gen::PrimitiveTransform, Fill, Structure as SiteStructure},
util::{attempt, Grid, RandomField, Sampler, CARDINALS, DIRS},
Land,
};
@ -21,7 +21,6 @@ use fxhash::FxHasher64;
use lazy_static::lazy_static;
use rand::{prelude::*, seq::SliceRandom};
use serde::Deserialize;
use std::sync::Arc;
use vek::*;
pub struct Dungeon {
@ -909,8 +908,8 @@ pub fn spiral_staircase(
radius: f32,
inner_radius: f32,
stretch: f32,
) -> Box<dyn Fn(Vec3<i32>) -> bool> {
Box::new(move |pos: Vec3<i32>| {
) -> impl Fn(Vec3<i32>) -> bool + Copy {
move |pos: Vec3<i32>| {
let pos = pos - origin;
if (pos.xy().magnitude_squared() as f32) < inner_radius.powi(2) {
true
@ -921,15 +920,15 @@ pub fn spiral_staircase(
} else {
false
}
})
}
}
pub fn wall_staircase(
origin: Vec3<i32>,
radius: f32,
stretch: f32,
) -> Box<dyn Fn(Vec3<i32>) -> bool> {
Box::new(move |pos: Vec3<i32>| {
) -> impl Fn(Vec3<i32>) -> bool + Copy {
move |pos: Vec3<i32>| {
let pos = pos - origin;
if (pos.x.abs().max(pos.y.abs())) as f32 > 0.6 * radius {
((pos.x as f32).atan2(pos.y as f32) / (f32::consts::PI * 2.0) * stretch + pos.z as f32)
@ -938,15 +937,15 @@ pub fn wall_staircase(
} else {
false
}
})
}
}
pub fn inscribed_polystar(
origin: Vec2<i32>,
radius: f32,
sides: usize,
) -> Box<dyn Fn(Vec3<i32>) -> bool> {
Box::new(move |pos| {
) -> impl Fn(Vec3<i32>) -> bool + Copy {
move |pos| {
use std::f32::consts::TAU;
let rpos: Vec2<f32> = pos.xy().as_() - origin.as_();
let is_border = rpos.magnitude_squared() > (radius - 2.0).powi(2);
@ -962,30 +961,98 @@ pub fn inscribed_polystar(
line.distance_to_point(rpos) <= 1.0
});
is_border || is_line
})
}
}
pub fn make_wall_contours(
tiles: Arc<Grid<Tile>>,
floor_corner: Vec2<i32>,
pub fn make_wall_contours<'a>(
tiles: &'a Grid<Tile>,
tile_corner: Vec2<i32>,
tile_pos: Vec2<i32>,
floor_z: i32,
wall_thickness: f32,
tunnel_height: f32,
) -> Box<dyn Fn(Vec3<i32>) -> bool> {
Box::new(move |pos| {
let rpos = pos.xy() - floor_corner;
let dist_to_wall = tilegrid_nearest_wall(&tiles, rpos)
.map(|nearest| (nearest.distance_squared(rpos) as f32).sqrt())
.unwrap_or(TILE_SIZE as f32);
let tunnel_dist =
1.0 - (dist_to_wall - wall_thickness).max(0.0) / (TILE_SIZE as f32 - wall_thickness);
dist_to_wall < wall_thickness
|| ((pos.z - floor_z) as f32) >= tunnel_height * (1.0 - tunnel_dist.powi(4))
})
) -> impl Fn(Vec3<i32>) -> bool + Copy + 'a {
let mut wall_fn = |dir: Vec2<i32>| /* |dirs: &[Vec2<i32>]| dirs.iter()
.map(|dir| */{
tiles
.get(tile_pos + dir)
.filter(|tile| !tile.is_passable())
.and(Some(Aabr {
min: dir * TILE_SIZE,
max: (dir + 1) * TILE_SIZE - 1,
}))
}/*)*/;
// NOTE: There can never be more than 4 meaningful closest walls.
//
// * If a horizontal *or* vertical wall is present at a corner, we will always
// be closer to one of those walls than the corner (because we form a right triangle
// with the distance from horizontal, distance from vertical, and distance from corner).
// * Otherwise, we may use the corner wall, if present, in exchange for one of the two slots.
// * Since at most 2 corners are adjacent to a vertical or horizontal slot, and we can only use
// a slot if *both* adjacent edges are missing, we will never use up more slots than edges,
// even if all 4 corners are taken.
let x1 = wall_fn(Vec2::new(1, 0));
let y1 = wall_fn(Vec2::new(0, 1));
let x0 = wall_fn(Vec2::new(-1, 0));
let y0 = wall_fn(Vec2::new(0, -1));
let walls = [
x1.or(y1).or_else(|| wall_fn(Vec2::new(1, 1))),
y0.or(x0).or_else(|| wall_fn(Vec2::new(-1, -1))),
// if x1 is true it was already looked at
// if y1 is true it was already looked at
// if (x1,y1) is relevant it was already looked at
//
// Remaining options are (x1,y0) and (x0,y1).
// Since if x0 & y0, neither of these will be relevant, it doesn't matter which we pick
// unless this isn't the case, and we pick both.
x1.and(y1).or_else(|| wall_fn(Vec2::new(1, -1))),
y0.and(x0).or_else(|| wall_fn(Vec2::new(-1, 1))),
];
/* let walls = [
walls_iter.next().map(Some).unwrap_or(None),
walls_iter.next().map(Some).unwrap_or(None),
walls_iter.next().map(Some).unwrap_or(None),
walls_iter.next().map(Some).unwrap_or(None),
]; */
let size_recip = (TILE_SIZE as f32 - wall_thickness).recip();
let size_recip_2 = size_recip * size_recip;
let wall_thickness_2 = wall_thickness * wall_thickness;
const TILE_SIZE_2: i32 = TILE_SIZE * TILE_SIZE;
let size_offset = 1.0 + wall_thickness_2 * size_recip_2;
// let size_offset = 1.0 + wall_thickness * size_recip;
move |pos| {
let rpos = pos.xy() - /*floor_corner*/tile_corner;
let dist_to_wall =
walls
.into_iter()
.filter_map(|x| x)
.map(|x| x.projected_point(rpos).distance_squared(rpos))
.min()
.unwrap_or(TILE_SIZE_2) as f32;
/* let dist_to_wall = tilegrid_nearest_wall(&tiles, rpos)
.map(|nearest| (nearest.distance_squared(rpos) as f32)/*.sqrt()*/)
.unwrap_or(TILE_SIZE as f32); */
/* let tunnel_dist = dist_to_wall.mul_add(-size_recip_2, size_offset);
let tunnel_dist_2 = tunnel_dist.mul_add(-tunnel_dist, 1.0);
let tunnel_dist_3 = tunnel_dist_2.mul_add(-tunnel_height, (pos.z - floor_z) as f32); */
let tunnel_dist = dist_to_wall.sqrt().mul_add(-size_recip, size_offset);
let tunnel_dist_2 = tunnel_dist * tunnel_dist;
let tunnel_dist_2 = tunnel_dist_2.mul_add(-tunnel_dist_2, 1.0);
let tunnel_dist_3 = tunnel_dist_2.mul_add(-tunnel_height, (pos.z - floor_z) as f32);
dist_to_wall < wall_thickness_2 || tunnel_dist_3 >= 0.0
/* dist_to_wall < wall_thickness ||
// 1.0 - (dist_to_wall - wall_thickness) * size_recip;
((pos.z - floor_z) as f32) >= tunnel_height * (1.0 - tunnel_dist.powi(4)) */
/* false */
}
}
impl Floor {
fn render(&self, painter: &Painter, dungeon: &Dungeon, floor_z: i32) {
fn render<'a, F: Filler>(&self, painter: &Painter<'a>, dungeon: &Dungeon, floor_z: i32, filler: &mut FillFn<'a, '_, F>) {
// Calculate an AABB and corner for the AABB that covers the current floor.
let floor_corner = dungeon.origin + TILE_SIZE * self.tile_offset;
let floor_aabb = Aabb {
@ -993,7 +1060,7 @@ impl Floor {
max: (floor_corner + TILE_SIZE * self.tiles.size())
.with_z(floor_z + self.total_depth()),
};
let floor_prim = painter.prim(Primitive::Aabb(floor_aabb));
let floor_prim = painter.aabb(floor_aabb);
// This is copied from `src/layer/mod.rs`. It should be moved into
// a util file somewhere
@ -1014,28 +1081,6 @@ impl Floor {
let stone = Block::new(BlockKind::Rock, Rgb::new(150, 150, 175));
let stone_purple = Block::new(BlockKind::GlowingRock, Rgb::new(96, 0, 128));
// Sprites are randomly positioned and have random kinds, this primitive
// produces a box of dots that will later get truncated to just the
// floor, and the corresponding fill places the random kinds where the
// mask says to
let floor_sprite = painter.prim(Primitive::sampling(
floor_prim,
Box::new(|pos| RandomField::new(7331).chance(pos, 0.001)),
));
let floor_sprite_fill = Fill::Sampling(Arc::new(|pos| {
Some(Block::air(
match (RandomField::new(1337).get(pos) / 2) % 30 {
0 => SpriteKind::Apple,
1 => SpriteKind::VeloriteFrag,
2 => SpriteKind::Velorite,
3..=8 => SpriteKind::Mushroom,
9..=15 => SpriteKind::FireBowlGround,
_ => SpriteKind::ShortGrass,
},
))
}));
let wall_thickness = 3.0;
let tunnel_height = if self.final_level { 16.0 } else { 8.0 };
let pillar_thickness: i32 = 4;
@ -1043,76 +1088,134 @@ impl Floor {
// Several primitives and fills use the tile information for finding the nearest
// wall, a copy of the tilegrid for the floor is stored in an Arc to
// avoid making a copy for each primitive
let tiles = Arc::new(self.tiles.clone());
let tiles = /*Arc::new(self.tiles.clone())*/&self.tiles;
// The way the ceiling is curved around corners and near hallways is intricate
/* // The way the ceiling is curved around corners and near hallways is intricate
// enough that it's easiest to do with a sampling primitive, this gets
// masked per room so that it's more efficient to query
let wall_contours = painter.prim(Primitive::sampling(floor_prim, {
let tiles = Arc::clone(&tiles);
make_wall_contours(tiles, floor_corner, floor_z, wall_thickness, tunnel_height)
}));
let wall_contours = /* painter.sampling(floor_prim, /*{
// let tiles = Arc::clone(&tiles);*/
painter.arena.alloc_with(move || */make_wall_contours(tiles, floor_corner, floor_z, wall_thickness, tunnel_height)/* )
/*}*/)*/;
// The surface 1 unit thicker than the walls is used to place the torches onto
let wall_contour_surface = painter.prim(Primitive::sampling(floor_prim, {
let tiles = Arc::clone(&tiles);
make_wall_contours(
let wall_contour_surface = /*painter.sampling(floor_prim, /*{
// let tiles = Arc::clone(&tiles);*/
painter.arena.alloc_with(move || */make_wall_contours(
tiles,
floor_corner,
floor_z,
wall_thickness + 1.0,
tunnel_height - 1.0,
)
}));
)/*)
/*}*/)*/;
// Sprites are randomly positioned and have random kinds, this primitive
// produces a box of dots that will later get truncated to just the
// floor, and the corresponding fill places the random kinds where the
// mask says to
let floor_sprite = /*painter.sampling(
floor_prim,
&*/move |pos| RandomField::new(7331).chance(pos, 0.001) && !wall_contours(pos)
/*)*/;
let floor_sprite_fill = filler.sampling(
painter.arena.alloc_with(move || move |pos| {
floor_sprite(pos).then(|| Block::air(
match (RandomField::new(1337).get(pos) / 2) % 30 {
0 => SpriteKind::Apple,
1 => SpriteKind::VeloriteFrag,
2 => SpriteKind::Velorite,
3..=8 => SpriteKind::Mushroom,
9..=15 => SpriteKind::FireBowlGround,
_ => SpriteKind::ShortGrass,
},
))
}),
); */
// The sconces use a sampling-based fill to orient them properly relative to the
// walls/staircases/pillars
let light_offset: i32 = 7;
let sconces_wall = Fill::Sampling(Arc::new(move |pos| {
/* let sconces_wall = /*filler.sampling(painter.arena.alloc_with(move || */move |pos: Vec3<i32>| {
let rpos = pos.xy() - floor_corner;
let nearest = tilegrid_nearest_wall(&tiles, rpos);
let ori = Floor::relative_ori(rpos, nearest.unwrap_or_default());
Block::air(SpriteKind::WallSconce).with_ori(ori)
}));
let sconces_inward = Fill::Sampling(Arc::new(move |pos| {
}/*))*/;*/
// FIXME: Per tile.
let sconces_inward = move |pos: Vec3<i32>| {
let rpos = pos.xy() - floor_corner;
let tile_pos = rpos.map(|e| e.div_euclid(TILE_SIZE));
let tile_center = tile_pos * TILE_SIZE + TILE_SIZE / 2;
let ori = Floor::relative_ori(rpos, tile_center);
Block::air(SpriteKind::WallSconce).with_ori(ori)
}));
let sconces_outward = Fill::Sampling(Arc::new(move |pos| {
};
let sconces_inward = filler.sampling(/*painter.arena.alloc_with(move || */&sconces_inward/*)*/);
let sconces_outward = move |pos: Vec3<i32>| {
let rpos = pos.xy() - floor_corner;
let tile_pos = rpos.map(|e| e.div_euclid(TILE_SIZE));
let tile_center = tile_pos * TILE_SIZE + TILE_SIZE / 2;
let ori = Floor::relative_ori(tile_center, rpos);
Block::air(SpriteKind::WallSconce).with_ori(ori)
};
let sconces_outward = filler.sampling(/*painter.arena.alloc_with(move || */&sconces_outward/*)*/);/*
// NOTE: Might be easier to just draw stuff first, then draw the walls over them...
let lava_within_walls = filler.sampling(painter.arena.alloc_with(move || move |pos: Vec3<i32>| {
(!wall_contours(pos)).then_some(lava)
}));
let vacant_within_walls = filler.sampling(painter.arena.alloc_with(move || move |pos: Vec3<i32>| {
(!wall_contours(pos)).then_some(vacant)
}));
let sconces_layer_fill = filler.sampling(painter.arena.alloc_with(move || move |pos| {
// NOTE: This intersection feels a bit wasteful...
(wall_contour_surface(pos) && !wall_contours(pos)).then(|| sconces_wall(pos)).flatten()
})); */
// The lighting mask is a grid of thin AABB planes with the same period as the
// tile grid, but offset by `lighting_offset`, used to space the torches
// on the walls/pillars/staircases
let lighting_mask = {
let mut lighting_mask_x = painter.prim(Primitive::Empty);
let floor_w = floor_aabb.max.x - floor_aabb.min.x;
for i in 0..floor_w / light_offset {
let lighting_mask_x = painter.union_all((0..floor_w / light_offset).map(|i| {
let j = floor_corner.x + i * TILE_SIZE + light_offset;
let plane = painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: floor_aabb.min.with_x(j - 1),
max: floor_aabb.max.with_x(j),
}));
lighting_mask_x = painter.prim(Primitive::union(plane, lighting_mask_x));
}
let mut lighting_mask_y = painter.prim(Primitive::Empty);
}).into()
}));
let floor_h = floor_aabb.max.y - floor_aabb.min.y;
for i in 0..floor_h / light_offset {
let lighting_mask_y = painter.union_all((0..floor_h / light_offset).map(|i| {
let j = floor_corner.y + i * TILE_SIZE + light_offset;
let plane = painter.prim(Primitive::Aabb(Aabb {
painter.aabb(Aabb {
min: floor_aabb.min.with_y(j - 1),
max: floor_aabb.max.with_y(j),
}));
lighting_mask_y = painter.prim(Primitive::union(plane, lighting_mask_y));
}).into()
}));
/*
let mut lighting_mask_x = painter.empty();
for i in 0..floor_w / light_offset {
let j = floor_corner.x + i * TILE_SIZE + light_offset;
let plane = painter.aabb(Aabb {
min: floor_aabb.min.with_x(j - 1),
max: floor_aabb.max.with_x(j),
});
lighting_mask_x = plane.union(lighting_mask_x);
}
let floor_h = floor_aabb.max.y - floor_aabb.min.y;
let mut lighting_mask_y = painter.empty();
for i in 0..floor_h / light_offset {
let j = floor_corner.y + i * TILE_SIZE + light_offset;
let plane = painter.aabb(Aabb {
min: floor_aabb.min.with_y(j - 1),
max: floor_aabb.max.with_y(j),
});
lighting_mask_y = plane.union(lighting_mask_y);
} */
lighting_mask_x
.union(lighting_mask_y)
.without(lighting_mask_x.intersect(lighting_mask_y))
@ -1120,7 +1223,6 @@ impl Floor {
// Declare collections of various disjoint primitives that need postprocessing
// after handling all the local information per-tile
let mut stairs_bb = Vec::new();
let mut stairs = Vec::new();
let mut pillars = Vec::new();
let mut boss_room_center = None;
@ -1144,21 +1246,108 @@ impl Floor {
};
// Sprites are contained to the level above the floor, and not within walls
let sprite_layer = painter.prim(Primitive::Aabb(aabr_with_z(
let sprite_layer = painter.aabb(aabr_with_z(
tile_aabr,
floor_z..floor_z + 1,
)));
let sprite_layer = painter.prim(Primitive::without(sprite_layer, wall_contours));
));
// let sprite_layer_fill = move |pos: Vec3<i32>| !wall_contours(pos);
/* let sprite_layer = sprite_layer.without(wall_contours); */
// Lights are 2 units above the floor, and aligned with the `lighting_mask` grid
let lighting_plane = painter.prim(Primitive::Aabb(aabr_with_z(
let lighting_plane = painter.aabb(aabr_with_z(
tile_aabr,
floor_z + 1..floor_z + 2,
)));
let lighting_plane = painter.prim(Primitive::intersect(lighting_plane, lighting_mask));
));
let lighting_plane = lighting_plane.intersect(lighting_mask);
let mut chests = None;
// The way the ceiling is curved around corners and near hallways is intricate
// enough that it's easiest to do with a sampling primitive, this gets
// masked per room so that it's more efficient to query
let wall_contours = /* painter.sampling(floor_prim, /*{
// let tiles = Arc::clone(&tiles);*/
painter.arena.alloc_with(move || */make_wall_contours(tiles, /*floor_corner*/tile_corner, tile_pos, floor_z, wall_thickness, tunnel_height)/* )
/*}*/)*/;
// The surface 1 unit thicker than the walls is used to place the torches onto
let wall_contour_surface = /*painter.sampling(floor_prim, /*{
// let tiles = Arc::clone(&tiles);*/
painter.arena.alloc_with(move || */make_wall_contours(
tiles,
/*floor_corner*/tile_corner,
tile_pos,
floor_z,
wall_thickness + 1.0,
tunnel_height - 1.0,
)/*)
/*}*/)*/;
// Sprites are randomly positioned and have random kinds, this primitive
// produces a box of dots that will later get truncated to just the
// floor, and the corresponding fill places the random kinds where the
// mask says to
let floor_sprite = /*painter.sampling(
floor_prim,
&*/move |pos| RandomField::new(7331).chance(pos, 0.001) && !wall_contours(pos)
/*)*/;
/* fn make_fill(fill: impl Fn(Vec3<i32>) -> Option<Block>) -> impl Fill {
move |pos, _| fill(pos)
} */
let floor_sprite_fill = /*make_fill*/filler.sampling(/*filler.sampling(*/
painter.arena.alloc_with(move || move |pos| {
floor_sprite(pos).then(|| Block::air(
match (RandomField::new(1337).get(pos) / 2) % 30 {
0 => SpriteKind::Apple,
1 => SpriteKind::VeloriteFrag,
2 => SpriteKind::Velorite,
3..=8 => SpriteKind::Mushroom,
9..=15 => SpriteKind::FireBowlGround,
_ => SpriteKind::ShortGrass,
},
))
}) as &dyn Fn(_) -> _/*,
)*/);
// The sconces use a sampling-based fill to orient them properly relative to the
// walls/staircases/pillars
let sconces_wall = /*filler.sampling(painter.arena.alloc_with(move || */move |pos: Vec3<i32>| {
let rpos = pos.xy() - floor_corner;
let nearest = tilegrid_nearest_wall(&tiles, rpos);
let ori = Floor::relative_ori(rpos, nearest.unwrap_or_default());
Block::air(SpriteKind::WallSconce).with_ori(ori)
}/*))*/;
/* let sconces_inward = filler.sampling(painter.arena.alloc_with(move || move |pos: Vec3<i32>| {
let rpos = pos.xy() - floor_corner;
let tile_pos = rpos.map(|e| e.div_euclid(TILE_SIZE));
let tile_center = tile_pos * TILE_SIZE + TILE_SIZE / 2;
let ori = Floor::relative_ori(rpos, tile_center);
Block::air(SpriteKind::WallSconce).with_ori(ori)
}));
let sconces_outward = filler.sampling(painter.arena.alloc_with(move || move |pos: Vec3<i32>| {
let rpos = pos.xy() - floor_corner;
let tile_pos = rpos.map(|e| e.div_euclid(TILE_SIZE));
let tile_center = tile_pos * TILE_SIZE + TILE_SIZE / 2;
let ori = Floor::relative_ori(tile_center, rpos);
Block::air(SpriteKind::WallSconce).with_ori(ori)
})); */
// NOTE: Might be easier to just draw stuff first, then draw the walls over them...
let lava_within_walls = move |pos: Vec3<i32>| {
(!wall_contours(pos)).then_some(lava)
};
let lava_within_walls = filler.sampling(/*painter.arena.alloc_with(move || */&lava_within_walls/*)*/);
let vacant_within_walls = move |pos: Vec3<i32>| {
(!wall_contours(pos)).then_some(vacant)
};
let vacant_within_walls = filler.sampling(/*painter.arena.alloc_with(move || */&vacant_within_walls/*)*/);
let sconces_layer_fill = move |pos| {
// NOTE: This intersection feels a bit wasteful...
(!wall_contours(pos) && wall_contour_surface(pos)).then(|| sconces_wall(pos)).flatten()
};
let sconces_layer_fill = filler.sampling(/*painter.arena.alloc_with(move || */&sconces_layer_fill/*)*/);
if let Some(room) = room.map(|i| self.rooms.get(*i)) {
height = height.min(room.height);
if let Tile::UpStair(_, kind) = tile {
@ -1168,36 +1357,42 @@ impl Floor {
let center = tile_center.with_z(floor_z);
let radius = TILE_SIZE as f32 / 2.0;
let aabb = aabr_with_z(tile_aabr, floor_z..floor_z + self.total_depth());
let bb = painter.prim(match kind {
StairsKind::Spiral => Primitive::Cylinder(aabb),
StairsKind::WallSpiral => Primitive::Aabb(aabb),
});
let stair = painter.prim(Primitive::sampling(bb, match kind {
StairsKind::Spiral => spiral_staircase(center, radius, 0.5, 9.0),
StairsKind::WallSpiral => wall_staircase(center, radius, 27.0),
}));
let bb = match kind {
StairsKind::Spiral => painter.cylinder(aabb),
StairsKind::WallSpiral => painter.aabb(aabb).as_kind(),
};
let stair = /*filler.sampling/*painter.sampling*/(*//*bb, */filler.sampling(match kind {
StairsKind::Spiral => &*painter.arena.alloc_with(move || {
let f = spiral_staircase(center, radius, 0.5, 9.0);
move |pos| f(pos).then_some(stone)
}) as &dyn Fn(_) -> _,
StairsKind::WallSpiral => &*painter.arena.alloc_with(move || {
let f = wall_staircase(center, radius, 27.0);
move |pos| f(pos).then_some(stone)
}) as &dyn Fn(_) -> _,
}/*)*/);
// Construct the lights that go inside the staircase, starting above the
// ceiling to avoid placing them floating in mid-air
let mut lights = painter.prim(Primitive::Empty);
let mut lights = painter.empty();
for i in height..self.total_depth() {
if i % 9 == 0 {
let mut light = painter.prim(Primitive::Aabb(Aabb {
let mut light = painter.aabb(Aabb {
min: aabb.min.with_z(floor_z + i),
max: aabb.max.with_z(floor_z + i + 1),
}));
let inner = painter.prim(Primitive::Aabb(Aabb {
});
let inner = painter.aabb(Aabb {
min: (aabb.min + Vec3::new(1, 1, 0)).with_z(floor_z + i),
max: (aabb.max - Vec3::new(1, 1, 0)).with_z(floor_z + i + 1),
}));
});
light = painter.prim(Primitive::without(light, inner));
lights = painter.prim(Primitive::union(light, lights));
light = light.without(inner);
lights = light.union(lights);
}
}
lights = painter.prim(Primitive::intersect(lights, lighting_mask));
stairs_bb.push(bb);
stairs.push((stair, lights));
lights = lights.intersect(lighting_mask);
stairs.push((bb, stair, lights));
}
if matches!(tile, Tile::Room(_) | Tile::DownStair(_)) {
let seed = room.seed;
let loot_density = room.loot_density;
@ -1205,11 +1400,11 @@ impl Floor {
// Place chests with a random distribution based on the
// room's loot density in valid sprite locations,
// filled based on the room's difficulty
let chest_sprite = painter.prim(Primitive::sampling(
let chest_sprite = /*painter.sampling(
sprite_layer,
Box::new(move |pos| RandomField::new(seed).chance(pos, loot_density * 0.5)),
));
let chest_sprite_fill = Fill::Block(Block::air(match difficulty {
painter.arena.alloc_with(move || */move |pos| RandomField::new(seed).chance(pos, loot_density * 0.5) && !wall_contours(pos)/*),
)*/;
let chest_sprite_fill = /*filler.block(*/Block::air(match difficulty {
0 => SpriteKind::DungeonChest0,
1 => SpriteKind::DungeonChest1,
2 => SpriteKind::DungeonChest2,
@ -1217,28 +1412,34 @@ impl Floor {
4 => SpriteKind::DungeonChest4,
5 => SpriteKind::DungeonChest5,
_ => SpriteKind::Chest,
}));
chests = Some((chest_sprite, chest_sprite_fill));
}/*)*/);
let chest_sprite_fill = /*make_fill*/filler.sampling(/*filler.sampling(*/
painter.arena.alloc_with(move || move |pos| chest_sprite(pos).then_some(chest_sprite_fill))/*,
)*/ as &dyn Fn(_) -> _);
chests = Some(/*(chest_sprite, */chest_sprite_fill/*)*/);
// If a room has pits, place them
if room.pits.is_some() {
// Make an air pit
let tile_pit = painter.prim(Primitive::Aabb(aabr_with_z(
let tile_pit = painter.aabb(aabr_with_z(
tile_aabr,
floor_z - 7..floor_z,
)));
let tile_pit = painter.prim(Primitive::without(tile_pit, wall_contours));
painter.fill(tile_pit, Fill::Block(vacant));
));
/* let tile_pit_fill = filler.sampling(
painter.arena.alloc_with(move || move |pos|
);
let tile_pit = tile_pit.without(wall_contours); */
painter.fill(tile_pit, /*filler.block(vacant)*/vacant_within_walls, filler);
// Fill with lava
let tile_lava = painter.prim(Primitive::Aabb(aabr_with_z(
let tile_lava = painter.aabb(aabr_with_z(
tile_aabr,
floor_z - 7..floor_z - 5,
)));
let tile_lava = painter.prim(Primitive::without(tile_lava, wall_contours));
));
/* let tile_lava = tile_lava.without(wall_contours); */
//pits.push(tile_pit);
//pits.push(tile_lava);
painter.fill(tile_lava, Fill::Block(lava));
painter.fill(tile_lava, /*filler.block(lava)*/lava_within_walls, filler);
}
if room
.pits
@ -1247,12 +1448,12 @@ impl Floor {
})
.unwrap_or(false)
{
let platform = painter.prim(Primitive::Aabb(Aabb {
let platform = painter.aabb(Aabb {
min: (tile_center - Vec2::broadcast(pillar_thickness - 1))
.with_z(floor_z - 7),
max: (tile_center + Vec2::broadcast(pillar_thickness)).with_z(floor_z),
}));
painter.fill(platform, Fill::Block(stone));
});
painter.fill(platform, filler.block(stone), filler);
}
// If a room has pillars, the current tile aligns with the pillar spacing, and
@ -1273,28 +1474,34 @@ impl Floor {
matches!(self.tiles.get(other_tile_pos), Some(Tile::Room(_)))
})
{
let mut pillar = painter.prim(Primitive::Cylinder(Aabb {
let mut pillar = painter.cylinder(Aabb {
min: (tile_center - Vec2::broadcast(pillar_thickness - 1))
.with_z(floor_z),
max: (tile_center + Vec2::broadcast(pillar_thickness))
.with_z(floor_z + height),
}));
let base = painter.prim(Primitive::Cylinder(Aabb {
});
let base = painter.cylinder(Aabb {
min: (tile_center - Vec2::broadcast(1 + pillar_thickness - 1))
.with_z(floor_z),
max: (tile_center + Vec2::broadcast(1 + pillar_thickness))
.with_z(floor_z + 1),
}));
});
let scale = (pillar_thickness + 2) as f32 / pillar_thickness as f32;
/* let scale = (pillar_thickness + 2) as f32 / pillar_thickness as f32;
let mut lights = painter
.prim(Primitive::scale(pillar, Vec2::broadcast(scale).with_z(1.0)));
lights = painter.prim(Primitive::intersect(lighting_plane, lights));
.scale(pillar, Vec2::broadcast(scale).with_z(1.0)); */
let mut lights = painter.cylinder(Aabb {
min: (tile_center - Vec2::broadcast(2 + pillar_thickness - 1))
.with_z(floor_z),
max: (tile_center + Vec2::broadcast(2 + pillar_thickness))
.with_z(floor_z + height),
});
lights = lighting_plane.as_kind().intersect(lights);
// Only add the base (and shift the lights up)
// for boss-rooms pillars
if room.kind == RoomKind::Boss {
lights = painter.prim(Primitive::translate(lights, 3 * Vec3::unit_z()));
pillar = painter.prim(Primitive::union(pillar, base));
lights = lights.translate(3 * Vec3::unit_z());
pillar = pillar.union(base);
}
pillars.push((tile_center, pillar, lights));
}
@ -1308,40 +1515,51 @@ impl Floor {
}
// Carve out the room's air inside the walls
let tile_air = painter.prim(Primitive::Aabb(aabr_with_z(
let tile_air = painter.aabb(aabr_with_z(
tile_aabr,
floor_z..floor_z + height,
)));
let tile_air = painter.prim(Primitive::without(tile_air, wall_contours));
painter.fill(tile_air, Fill::Block(vacant));
));
/* let tile_air_fill = filler.sampling(painter.arena.alloc_with(move || move |pos| {
(!wall_contours(pos)).then_some(vacant)
})); */
// let tile_air = tile_air.without(wall_contours);
painter.fill(tile_air, /*filler.block(vacant)*//*tile_air_fill*/vacant_within_walls, filler);
// Place torches on the walls with the aforementioned spacing
let sconces_layer = painter.prim(Primitive::intersect(tile_air, lighting_plane));
let sconces_layer =
painter.prim(Primitive::intersect(sconces_layer, wall_contour_surface));
painter.fill(sconces_layer, sconces_wall.clone());
let sconces_layer = /*tile_air.intersect(*/lighting_plane/*)*/;
/* let sconces_layer =
sconces_layer.as_kind().intersect(wall_contour_surface); */
/* let sconces_layer_fill = filler.sampling(painter.arena.alloc_with(move || move |pos| {
// NOTE: This intersection feels a bit wasteful...
(wall_contour_surface(pos) && !wall_contours(pos)).then(|| sconces_wall(pos))
})); */
painter.fill(sconces_layer, /*sconces_wall*/sconces_layer_fill, filler);
// Defer chest/floor sprite placement
if let Some((chest_sprite, chest_sprite_fill)) = chests {
let chest_sprite = painter.prim(Primitive::without(chest_sprite, wall_contours));
sprites.push((chest_sprite, chest_sprite_fill));
if let Some(/*(chest_sprite, */chest_sprite_fill/*)*/) = chests {
// let chest_sprite = chest_sprite.without(wall_contours);
sprites.push((sprite_layer, chest_sprite_fill));
}
let floor_sprite = painter.prim(Primitive::intersect(sprite_layer, floor_sprite));
sprites.push((floor_sprite, floor_sprite_fill.clone()));
/* let floor_sprite = sprite_layer.as_kind().intersect(floor_sprite); */
sprites.push((sprite_layer, floor_sprite_fill));
}
// Place a glowing purple septagonal star inscribed in a circle in the boss room
if let Some(boss_room_center) = boss_room_center {
let magic_circle_bb = painter.prim(Primitive::Cylinder(Aabb {
let magic_circle_bb = painter.cylinder(Aabb {
min: (boss_room_center - 3 * Vec2::broadcast(TILE_SIZE) / 2).with_z(floor_z - 1),
max: (boss_room_center + 3 * Vec2::broadcast(TILE_SIZE) / 2).with_z(floor_z),
}));
let magic_circle = painter.prim(Primitive::sampling(
magic_circle_bb,
inscribed_polystar(boss_room_center, 1.4 * TILE_SIZE as f32, 7),
));
painter.fill(magic_circle, Fill::Block(stone_purple));
});
let magic_circle = {
let f = inscribed_polystar(boss_room_center, 1.4 * TILE_SIZE as f32, 7);
move |pos| f(pos).then_some(stone_purple)
};
let magic_circle = /*painter.sampling*/filler.sampling(
// magic_circle_bb,
/* painter.arena.alloc_with(move || */&magic_circle/*),*/
);
painter.fill(/*magic_circle*/magic_circle_bb, /*filler.block(stone_purple)*/magic_circle, filler);
}
// Place pillars and pillar lights facing the pillars
@ -1352,32 +1570,41 @@ impl Floor {
continue;
}
}
painter.fill(*lights, sconces_inward.clone());
painter.fill(*pillar, Fill::Block(stone));
painter.fill(*lights, sconces_inward, filler);
painter.fill(*pillar, filler.block(stone), filler);
}
// Carve out space for the stairs
for stair_bb in stairs_bb.iter() {
painter.fill(*stair_bb, Fill::Block(vacant));
// Prevent sprites from floating above the stairs
let stair_bb_up = painter.prim(Primitive::translate(*stair_bb, Vec3::unit_z()));
for (stair_bb, _, _) in stairs.iter() {
painter.fill(*stair_bb, filler.block(vacant), filler);
/* // Prevent sprites from floating above the stairs
//
// NOTE: This is *mostly* equivalent to a Z test, since sprites are always drawn in
// single-voxel ground layers, except that cylindrical stairs can generate
// non-convex differences with a tile. For now we leave it as is, but it could
// probably be made a lot cheaper (and we could likely avoid the difference entirely by
// just preventing sprites from spawning in the tile around staircases, whether or not
// they were a cylinder).
let stair_bb_up = stair_bb.translate(Vec3::unit_z());
for (sprite, _) in sprites.iter_mut() {
*sprite = painter.prim(Primitive::without(*sprite, stair_bb_up));
}
/* *sprite = */sprite.without(stair_bb_up);
} */
}
// Place the stairs themselves, and lights within the stairwells
for (stair, lights) in stairs.iter() {
painter.fill(*lights, sconces_outward.clone());
painter.fill(*stair, Fill::Block(stone));
}
let stairs_bb_up = painter.union_all(stairs.into_iter().map(|(stair_bb, stair, lights)| {
painter.fill(lights, sconces_outward, filler);
painter.fill(stair_bb, stair, filler);
stair_bb
})).translate(Vec3::unit_z());
// Place the sprites
for (sprite, sprite_fill) in sprites.into_iter() {
painter.fill(sprite, sprite_fill);
/* let sprite = */sprite.without(stairs_bb_up);
painter.fill(sprite, sprite_fill, filler);
}
}
}
impl SiteStructure for Dungeon {
fn render(&self, _site: &site2::Site, land: &Land, painter: &Painter) {
impl<F: Filler> SiteStructure<F> for Dungeon {
fn render<'a>(&self, _site: &site2::Site, land: Land, painter: &Painter<'a>, filler: &mut FillFn<'a, '_, F>) {
let origin = (self.origin + Vec2::broadcast(TILE_SIZE / 2)).with_z(self.alt + ALT_OFFSET);
lazy_static! {
@ -1397,21 +1624,22 @@ impl SiteStructure for Dungeon {
BiomeKind::Desert => *DESERT,
_ => *GRASSLAND,
};
let entrances = entrances.read();
let entrance = entrances[self.seed as usize % entrances.len()].clone();
let entrances = entrances.get();
let entrance = &entrances[self.seed as usize % entrances.len()];
let entrance_prim = painter.prim(Primitive::Prefab(Box::new(entrance.clone())));
let entrance_prim = painter.prim(Primitive::translate(entrance_prim, origin));
let entrance_prim = painter.prefab(entrance);
let entrance_prim = entrance_prim.translate(origin);
painter.fill(
entrance_prim,
Fill::Prefab(Box::new(entrance), origin, self.seed),
filler.prefab(entrance, origin, self.seed),
filler,
);
let mut z = self.alt + ALT_OFFSET;
for floor in &self.floors {
z -= floor.total_depth();
floor.render(painter, self, z);
floor.render(painter, self, z, filler);
}
}
}

19
world/src/site2/plot/giant_tree.rs
View File

@ -1,7 +1,7 @@
use crate::{
layer::tree::{ProceduralTree, TreeConfig},
site::namegen::NameGen,
site2::{Fill, Painter, Site, Structure},
site2::{Fill, Filler, FillFn, Painter, Site, Structure},
util::FastNoise,
Land, Sampler,
};
@ -78,8 +78,8 @@ impl GiantTree {
}
}
impl Structure for GiantTree {
fn render(&self, _site: &Site, _land: &Land, painter: &Painter) {
impl<F: Filler> Structure<F> for GiantTree {
fn render<'a>(&self, _site: &Site, _land: Land, painter: &Painter<'a>, filler: &mut FillFn<'a, '_, F>) {
let fast_noise = FastNoise::new(self.seed);
let dark = Rgb::new(10, 70, 50).map(|e| e as f32);
let light = Rgb::new(80, 140, 10).map(|e| e as f32);
@ -88,23 +88,25 @@ impl Structure for GiantTree {
light,
fast_noise.get((self.wpos.map(|e| e as f64) * 0.05) * 0.5 + 0.5),
);
let leaf_vertical_scale = /*t.config.leaf_vertical_scale*/0.6f32.recip()/*1.0*/;
self.tree.walk(|branch, parent| {
let aabr = Aabr {
min: self.wpos.xy() + branch.get_aabb().min.xy().as_(),
max: self.wpos.xy() + branch.get_aabb().max.xy().as_(),
};
if aabr.collides_with_aabr(painter.render_aabr().as_()) {
if aabr.collides_with_aabr(filler.render_aabr().as_()) {
painter
.line_two_radius(
self.wpos + branch.get_line().start.as_(),
self.wpos + branch.get_line().end.as_(),
parent.get_wood_radius(),
branch.get_wood_radius(),
1.0,
)
.fill(Fill::Block(Block::new(
.fill(filler.block(Block::new(
BlockKind::Wood,
Rgb::new(80, 32, 0),
)));
)), filler);
if branch.get_leaf_radius() > branch.get_wood_radius() {
painter
.line_two_radius(
@ -112,11 +114,12 @@ impl Structure for GiantTree {
self.wpos + branch.get_line().end.as_(),
parent.get_leaf_radius(),
branch.get_leaf_radius(),
leaf_vertical_scale,
)
.fill(Fill::Block(Block::new(
.fill(filler.block(Block::new(
BlockKind::Leaves,
leaf_col.map(|e| e as u8),
)))
)), filler)
}
true
} else {

669
world/src/site2/plot/gnarling.rs
View File

File diff suppressed because it is too large Load Diff

953
world/src/site2/plot/house.rs
View File

File diff suppressed because it is too large Load Diff

29
world/src/site2/plot/workshop.rs
View File

@ -39,29 +39,29 @@ impl Workshop {
}
}
impl Structure for Workshop {
fn render(&self, _site: &Site, _land: &Land, painter: &Painter) {
let brick = Fill::Brick(BlockKind::Rock, Rgb::new(80, 75, 85), 24);
impl<F: Filler> Structure<F> for Workshop {
fn render<'a>(&self, _site: &Site, _land: Land, painter: &Painter<'a>, filler: &mut FillFn<'a, '_, F>) {
let brick = filler.brick(BlockKind::Rock, Rgb::new(80, 75, 85), 24);
let base = self.alt + 1;
let center = self.bounds.center();
// Base
painter
.aabb(Aabb {
.aabb/*::<super::gen::Cbn>*/(Aabb {
min: (self.bounds.min + 1).with_z(base - 16),
max: self.bounds.max.with_z(base),
})
.fill(brick.clone());
.fill(brick, filler);
let roof = base + 5;
painter
.aabb(Aabb {
.aabb/*::<super::gen::Cbn>*/(Aabb {
min: (self.bounds.min + 2).with_z(base),
max: (self.bounds.max - 1).with_z(roof),
})
.clear();
.clear(filler);
// Supports
for pos in [
@ -72,10 +72,10 @@ impl Structure for Workshop {
] {
painter
.line(pos.with_z(base), pos.with_z(roof), 1.0)
.fill(Fill::Block(Block::new(
.fill(filler.block(Block::new(
BlockKind::Wood,
Rgb::new(55, 25, 8),
)));
)), filler);
}
let roof_top = roof + 5;
@ -86,7 +86,7 @@ impl Structure for Workshop {
min: (self.bounds.min + 2).with_z(roof),
max: (self.bounds.max - 1).with_z(roof_top),
})
.fill(Fill::Brick(BlockKind::Rock, Rgb::new(45, 28, 21), 24));
.fill(filler.brick(BlockKind::Rock, Rgb::new(45, 28, 21), 24), filler);
let chimney = roof_top + 2;
@ -98,19 +98,20 @@ impl Structure for Workshop {
center.with_z(chimney),
chimney_radius,
)
.fill(brick);
.fill(brick, filler);
painter
.line(
center.with_z(base),
center.with_z(chimney + 2),
chimney_radius - 1.0,
)
.clear();
.clear(filler);
for x in -1..2 {
for y in -1..2 {
painter.sprite(
(center + Vec2::new(x, y)).with_z(base - 1),
SpriteKind::Ember,
filler,
);
}
}
@ -134,11 +135,11 @@ impl Structure for Workshop {
let cr_station = stations.swap_remove(
RandomField::new(0).get(position.with_z(base)) as usize % stations.len(),
);
painter.sprite(position.with_z(base), cr_station);
painter.sprite(position.with_z(base), cr_station, filler);
}
}
painter.spawn(
filler.spawn(
EntityInfo::at(self.bounds.center().with_z(base).map(|e| e as f32 + 0.5))
.into_waypoint(),
);

4
world/src/site2/tile.rs
View File

@ -215,6 +215,10 @@ impl Tile {
}
}
pub fn plot(&self) -> Option<Id<Plot>> {
self.plot
}
pub fn is_empty(&self) -> bool { self.kind == TileKind::Empty }
pub fn is_natural(&self) -> bool { matches!(self.kind, TileKind::Empty | TileKind::Hazard(_)) }

2
world/src/site2/util/gradient.rs
View File

@ -39,7 +39,7 @@ impl Shape {
pub fn radial_line(direction: Vec3<f32>) -> Self { Shape::Line(direction.normalized()) }
}
#[derive(Clone)]
#[derive(Clone, Copy)]
pub struct Gradient {
/// The center of the gradient shape
pub(super) center: Vec3<f32>,

50
world/src/util/structure.rs
View File

@ -116,6 +116,56 @@ impl StructureGen2d {
)
})
}
/// Note: Generates all possible closest samples for elements in the range
/// of min to max, *exclusive.*
pub fn iter(
&self,
min: Vec2<i32>,
max: Vec2<i32>,
) -> impl Iterator<Item = StructureField> {
let freq = self.freq;
let spread = self.spread;
let spread_mul = Self::spread_mul(spread);
assert!(spread * 2 == spread_mul);
assert!(spread_mul <= freq);
let spread = spread as i32;
let freq = freq as i32;
let freq_offset = Self::freq_offset(freq);
assert!(freq_offset * 2 == freq);
let min_index = Self::sample_to_index_internal(freq, min) - 1;
let max_index = Self::sample_to_index_internal(freq, max) + 1;
assert!(min_index.x < max_index.x);
// NOTE: xlen > 0
let xlen = (max_index.x - min_index.x) as u32;
assert!(min_index.y < max_index.y);
// NOTE: ylen > 0
let ylen = (max_index.y - min_index.y) as u32;
// NOTE: Cannot fail, since every product of u32s fits in a u64.
let len = ylen as u64 * xlen as u64;
// NOTE: since iteration is *exclusive* for the initial range, it's fine that we
// don't go up to the maximum value.
// NOTE: we convert to usize first, and then iterate, because we want to make
// sure we get a properly indexed parallel iterator that can deal with
// the whole range at once.
let x_field = self.x_field;
let y_field = self.y_field;
let seed_field = self.seed_field;
(0..len).into_iter().map(move |xy| {
let index = min_index + Vec2::new((xy % xlen as u64) as i32, (xy / xlen as u64) as i32);
Self::index_to_sample_internal(
freq,
freq_offset,
spread,
spread_mul,
x_field,
y_field,
seed_field,
index,
)
})
}
}
impl Sampler<'static> for StructureGen2d {