Jayrude
/
voxel-rs
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

WIP: World rewrite #2

Draft
Jayrude wants to merge 5 commits from world-rewrite into main
pull from: world-rewrite
merge into: Jayrude:main
Conversation 0 Commits 5 Files Changed 6 +98 -45
1 changed files with 98 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 9fc4594b9a - Show all commits

143
src/voxel/world/chunk.rs
View File

@ -1,3 +1,6 @@
use ndarray::{s, Array3};
use wgpu::naga::FastHashSet;
use crate::math; use crate::math;
use super::{GenerationSettings, Voxel}; use super::{GenerationSettings, Voxel};
@ -11,8 +14,9 @@ pub struct ChunkSettings {
#[derive(Debug)] #[derive(Debug)]
pub struct Chunk { pub struct Chunk {
settings: ChunkSettings, settings: ChunkSettings,
genned_blocks: FastHashSet<(usize, usize, usize)>,
noise: Vec<f32>, noise: Vec<f32>,
blocks: Vec<Vec<Voxel>>, blocks: Array3<Voxel>,
} }
impl Chunk { impl Chunk {
@ -42,13 +46,21 @@ impl Chunk {
.generate() .generate()
.0; .0;
let num_blocks = dims.x * dims.y * dims.z; let genned_blocks = FastHashSet::default();
let blocks = vec![vec![]; num_blocks as usize];
let shape = chunk_settings.dimensions * chunk_settings.block_dimensions;
let num_voxels = shape.x * shape.y * shape.z;
let blocks = Array3::from_shape_vec(
(shape.x as usize, shape.y as usize, shape.z as usize),
vec![Voxel::Empty; num_voxels as usize],
)
.unwrap();
Self { Self {
settings: chunk_settings, settings: chunk_settings,
noise, noise,
blocks, blocks,
genned_blocks,
} }
} }
@ -57,57 +69,84 @@ impl Chunk {
region_start: glam::UVec3, region_start: glam::UVec3,
region_dims: glam::UVec3, region_dims: glam::UVec3,
) -> Vec<Voxel> { ) -> Vec<Voxel> {
let mut voxels = vec![];
let start = region_start; let start = region_start;
let end = region_start + region_dims; let end = region_start + region_dims;
let dims = self.settings.dimensions * self.settings.block_dimensions; let dims = self.settings.dimensions * self.settings.block_dimensions;
assert!(end.x <= dims.x && end.y <= dims.y && end.z <= dims.z); assert!(end.x <= dims.x && end.y <= dims.y && end.z <= dims.z);
for z in (start.z)..(end.z) { // Check that all the blocks needed are generated and generated them if needed
for y in (start.y)..(end.y) { // TODO: Don't hardcode this division!!
for x in (start.x)..(end.x) { let start_block = start / 8;
voxels.push(self.get_voxel(glam::uvec3(x, y, z))); let end_block = end / 8;
for z in start_block.z..(end_block.z) {
for y in (start_block.y)..(end_block.y) {
for x in (start_block.x)..(end_block.x) {
if !self
.genned_blocks
.contains(&(x as usize, y as usize, z as usize))
{
self.gen_block(glam::uvec3(x, y, z));
}
} }
} }
} }
voxels //
let region = self
.blocks
.slice(s![
(start.x as usize)..(end.x as usize),
(start.y as usize)..(end.y as usize),
(start.z as usize)..(end.z as usize)
])
.to_owned()
.into_raw_vec();
// dbg!(&region);
region
} }
pub fn get_voxel(&mut self, pos: glam::UVec3) -> Voxel { // pub fn get_voxel(&mut self, pos: glam::UVec3) -> Voxel {
let dims = self.settings.dimensions * self.settings.block_dimensions; // let dims = self.settings.dimensions * self.settings.block_dimensions;
debug_assert!(pos.x < dims.x && pos.y < dims.y && pos.z < dims.z); // debug_assert!(pos.x < dims.x && pos.y < dims.y && pos.z < dims.z);
let block_pos = pos / self.settings.block_dimensions; // let block_pos = pos / self.settings.block_dimensions;
let block_idx = math::to_1d_index(block_pos, self.settings.dimensions); // let block_idx = math::to_1d_index(block_pos, self.settings.dimensions);
let mut block = &self.blocks[block_idx]; // let mut block = &self.blocks[block_idx];
if block.is_empty() { // if block.is_empty() {
self.gen_block(block_pos, block_idx); // self.gen_block(block_pos, block_idx);
block = &self.blocks[block_idx] // block = &self.blocks[block_idx]
} // }
let local_pos = pos % self.settings.block_dimensions; // let local_pos = pos % self.settings.block_dimensions;
let local_idx = math::to_1d_index(local_pos, self.settings.block_dimensions); // let local_idx = math::to_1d_index(local_pos, self.settings.block_dimensions);
block[local_idx] // block[local_idx]
} // }
pub fn get_block(&mut self, pos: glam::UVec3) -> Vec<Voxel> { pub fn get_block(&mut self, pos: glam::UVec3) -> Vec<Voxel> {
let dims = self.settings.dimensions; let dims = self.settings.dimensions;
assert!(pos.x < dims.x && pos.y < dims.y && pos.z < dims.z); assert!(pos.x < dims.x && pos.y < dims.y && pos.z < dims.z);
let block_idx = math::to_1d_index(pos, dims); let gen_key = &(pos.x as usize, pos.y as usize, pos.z as usize);
let mut block = &self.blocks[block_idx]; if !self.genned_blocks.contains(gen_key) {
if block.is_empty() { self.gen_block(pos);
self.gen_block(pos, block_idx);
block = &self.blocks[block_idx]
} }
block.to_owned() let block_dims = self.settings.block_dimensions;
let start = pos * block_dims;
let end = start + block_dims;
let region = self
.blocks
.slice(s![
(start.x as usize)..(end.x as usize),
(start.y as usize)..(end.y as usize),
(start.z as usize)..(end.z as usize)
])
.to_owned()
.into_raw_vec();
region
} }
pub fn gen_block(&mut self, block_pos: glam::UVec3, block_idx: usize) { pub fn gen_block(&mut self, block_pos: glam::UVec3) {
let block = &mut self.blocks[block_idx];
let noise_dims = self.settings.dimensions + glam::uvec3(1, 1, 1); let noise_dims = self.settings.dimensions + glam::uvec3(1, 1, 1);
// Extract relevant noise values from the chunk // Extract relevant noise values from the chunk
@ -126,32 +165,46 @@ impl Chunk {
} }
// If all the corners are negative, then all the interpolated values // If all the corners are negative, then all the interpolated values
// will be negative too. In that case we can just fill with empty. // will be negative too. The chunk voxels are initialised as empty already
if block_sign == -8.0 { // so we only need to modify them if we have at least one positive corner
block.resize(512, Voxel::Empty); if block_sign != -8.0 {
} else {
let mut vals = [0.0f32; 512]; let mut vals = [0.0f32; 512];
math::tri_lerp_block(&noise_vals, &[8, 8, 8], &mut vals); math::tri_lerp_block(&noise_vals, &[8, 8, 8], &mut vals);
let block_dims = self.settings.block_dimensions;
let start = block_pos * block_dims;
let end = start + block_dims;
let mut block = self.blocks.slice_mut(s![
(start.x as usize)..(end.x as usize),
(start.y as usize)..(end.y as usize),
(start.z as usize)..(end.z as usize)
]);
// TODO: Better voxel colours // TODO: Better voxel colours
let mut idx = 0; let mut val_idx = 0;
for z in 0..8 { for z in 0..block_dims.z {
for y in 0..8 { for y in 0..block_dims.y {
for x in 0..8 { for x in 0..block_dims.x {
let val = vals[idx]; let val = vals[val_idx];
idx += 1; val_idx += 1;
if val > 0.0 { if val > 0.0 {
let r = ((x + 1) * 32 - 1) as u8; let r = ((x + 1) * 32 - 1) as u8;
let g = ((y + 1) * 32 - 1) as u8; let g = ((y + 1) * 32 - 1) as u8;
let b = ((z + 1) * 32 - 1) as u8; let b = ((z + 1) * 32 - 1) as u8;
block.push(Voxel::Color(r, g, b)); let block_idx = [z as usize, y as usize, x as usize];
} else { block[block_idx] = Voxel::Color(r, g, b);
block.push(Voxel::Empty);
} }
} }
} }
} }
} }
let key = (
block_pos.x as usize,
block_pos.y as usize,
block_pos.z as usize,
);
self.genned_blocks.insert(key);
} }
} }