Replace usage of hardcoded block dimensions

Cargo.lock

@@ -829,6 +829,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "matrixmultiply"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7574c1cf36da4798ab73da5b215bbf444f50718207754cb522201d78d1cd0ff2"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
 [[package]]
 name = "memchr"
 version = "2.7.1"
@@ -879,6 +889,19 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "ndarray"
+version = "0.15.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb12d4e967ec485a5f71c6311fe28158e9d6f4bc4a447b474184d0f91a8fa32"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "rawpointer",
+]
+
 [[package]]
 name = "ndk"
 version = "0.8.0"
@@ -909,6 +932,24 @@ dependencies = [
  "jni-sys",
 ]
 
+[[package]]
+name = "num-complex"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23c6602fda94a57c990fe0df199a035d83576b496aa29f4e634a8ac6004e68a6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.18"
@@ -1156,6 +1197,12 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42a9830a0e1b9fb145ebb365b8bc4ccd75f290f98c0247deafbbe2c75cefb544"
 
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -1540,6 +1587,7 @@ dependencies = [
  "env_logger",
  "glam",
  "log",
+ "ndarray",
  "pollster",
  "simdnoise",
  "wgpu",

Cargo.toml

@@ -11,6 +11,7 @@ bytemuck = { version = "1.15.0", features = ["derive"] }
 env_logger = "0.11.3"
 glam = "0.26.0"
 log = "0.4.21"
+ndarray = "0.15.6"
 pollster = "0.3.0"
 simdnoise = "3.1.6"
 wgpu = "0.19.3"

src/voxel/world/chunk.rs

@@ -1,3 +1,6 @@
+use ndarray::{s, Array3};
+use wgpu::naga::FastHashSet;
+
 use crate::math;
 
 use super::{GenerationSettings, Voxel};
@@ -11,8 +14,9 @@ pub struct ChunkSettings {
 #[derive(Debug)]
 pub struct Chunk {
     settings: ChunkSettings,
+    genned_blocks: FastHashSet<(usize, usize, usize)>,
     noise: Vec<f32>,
-    blocks: Vec<Vec<Voxel>>,
+    blocks: Array3<Voxel>,
 }
 
 impl Chunk {
@@ -42,32 +46,107 @@ impl Chunk {
         .generate()
         .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 {
             settings: chunk_settings,
             noise,
             blocks,
+            genned_blocks,
         }
     }
 
+    pub fn get_region(
+        &mut self,
+        region_start: glam::UVec3,
+        region_dims: glam::UVec3,
+    ) -> Vec<Voxel> {
+        let start = region_start;
+        let end = region_start + region_dims;
+        let dims = self.settings.dimensions * self.settings.block_dimensions;
+        assert!(end.x <= dims.x && end.y <= dims.y && end.z <= dims.z);
+
+        // Check that all the blocks needed are generated and generated them if needed
+        let block_dims = self.settings.block_dimensions;
+        let start_block = start / block_dims;
+        let end_block = end / block_dims;
+        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));
+                    }
+                }
+            }
+        }
+
+        //
+        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 {
+    //     let dims = self.settings.dimensions * self.settings.block_dimensions;
+    //     debug_assert!(pos.x < dims.x && pos.y < dims.y && pos.z < dims.z);
+
+    //     let block_pos = pos / self.settings.block_dimensions;
+    //     let block_idx = math::to_1d_index(block_pos, self.settings.dimensions);
+    //     let mut block = &self.blocks[block_idx];
+    //     if block.is_empty() {
+    //         self.gen_block(block_pos, block_idx);
+    //         block = &self.blocks[block_idx]
+    //     }
+
+    //     let local_pos = pos % self.settings.block_dimensions;
+    //     let local_idx = math::to_1d_index(local_pos, self.settings.block_dimensions);
+    //     block[local_idx]
+    // }
+
     pub fn get_block(&mut self, pos: glam::UVec3) -> Vec<Voxel> {
         let dims = self.settings.dimensions;
         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);
 
         // Extract relevant noise values from the chunk
@@ -86,32 +165,51 @@ impl Chunk {
         }
 
         // 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 block_dims = self.settings.block_dimensions;
+
             let mut vals = [0.0f32; 512];
-            math::tri_lerp_block(&noise_vals, &[8, 8, 8], &mut vals);
+            math::tri_lerp_block(
+                &noise_vals,
+                &[block_dims.x, block_dims.y, block_dims.z],
+                &mut vals,
+            );
+
+            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
-            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 {
                             let r = ((x + 1) * 32 - 1) as u8;
                             let g = ((y + 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);
     }
 }

src/voxel/world/manager.rs

@@ -31,7 +31,10 @@ impl WorldManager {
         }
 
         let chunk = self.chunks.get_mut(&chunk_pos).unwrap();
-        chunk.get_block(local_pos)
+        let block_dims = self.chunk_settings.block_dimensions;
+        chunk.get_region(local_pos * block_dims, block_dims)
+
+        // chunk.get_block(local_pos)
     }
 
     fn gen_chunk(&mut self, pos: glam::IVec3) -> Chunk {