Basic map chunking

src/gfx.rs

···
     window::Window,
 };
 
-use crate::{app::WASM_WIN_SIZE, gfx::model::Vertex, Instance, InstanceRaw};
+use crate::{app::WASM_WIN_SIZE, gfx::model::Vertex, map::{sl3get, Block, CHUNK_SIZE}, Instance, InstanceRaw};
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
···
 
 
         let camera = camera::Camera {
-            eye: vec3(0., 1., 2.),
+            eye: vec3(50., 20., 50.),
             target: Vec3::ZERO,
             up: Vec3::Y,
             aspect: surface_config.width as f32 / surface_config.height as f32,
···
             bind_group: camera_bind_group,
         };
 
-        const NUM_INSTANCES_PER_ROW: u32 = 10;
+        // MAP LOAD
+
+        let map = crate::map::new_map();
+
+        let mut instances = vec![];
+
         const SPACE_BETWEEN: f32 = 3.0;
-        let instances = itertools::iproduct!(0..NUM_INSTANCES_PER_ROW, 0..NUM_INSTANCES_PER_ROW)
-            .map(|(x, z)| {
-                let mapping = |n| SPACE_BETWEEN * (n as f32 - NUM_INSTANCES_PER_ROW as f32 / 2.0);
-                let position = vec3(mapping(x), 0.0, mapping(z));
+        for (_coords, chunk) in map.chunks {
+            let _3diter = itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2);
+
+            let mut i = _3diter.filter_map(|(x,y,z)| {
+
+                if let Block::AIR = sl3get(&chunk.blocks, x, y, z) {
+                    return None;
+                }
+
+                let mapping = |n| SPACE_BETWEEN * (n as f32 - CHUNK_SIZE.0 as f32 / 2.0);
+                let position = vec3(mapping(x), -mapping(y), mapping(z));
 
                 // this is needed so an object at (0, 0, 0) won't get scaled to zero
                 // as Quaternions can affect scale if they're not created correctly
···
                     _ => Quat::from_axis_angle(Vec3::Z, 0.0),
                 };
 
-                Instance { position, rotation }
-            })
-            .collect::<Vec<_>>();
+                Some(Instance { position, rotation })
+
+            }).collect::<Vec<_>>();
+
+            instances.append(&mut i);
+        }
 
         let instance_data = instances.iter().map(Instance::to_raw).collect::<Vec<_>>();
         let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {

src/lib.rs

···
 
 mod app;
 mod gfx;
+mod map;
 
 use glam::{Mat3, Mat4, Quat, Vec3};
 #[cfg(target_arch = "wasm32")]

src/map.rs

···
+use glam::IVec2;
+use std::collections::HashMap;
+
+// I have arbitrarily decided that this is (x,z,y) where +y is up.
+
+pub(crate) const CHUNK_SIZE: (usize, usize, usize) = (16, 16, 16);
+
+// A [Block; X*Y*Z] would be a much more efficient datatype, but, well...
+pub type Slice3 = [[[Block; CHUNK_SIZE.0]; CHUNK_SIZE.1]; CHUNK_SIZE.2];
+
+pub fn sl3get(sl3: &Slice3, x: usize, y: usize, z: usize) -> Block {
+    sl3[y][z][x]
+}
+pub fn sl3set(sl3: &mut Slice3, x: usize, y: usize, z: usize, new: Block) {
+    sl3[y][z][x] = new;
+}
+
+pub struct WorldMap {
+    pub chunks: HashMap<IVec2, Chunk>,
+}
+
+pub struct Chunk {
+    pub blocks: Slice3,
+}
+
+#[derive(Copy, Clone, Default)]
+#[repr(u32)]
+pub enum Block {
+    #[default]
+    AIR = 0,
+    BRICK,
+}
+
+
+fn new_chunk(world_x: i32, world_z: i32) -> Chunk {
+    let mut blocks = Slice3::default();
+
+    for (x, z, y) in itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2) {
+        let (xf, zf) = (
+            (x as i32 + (world_x * CHUNK_SIZE.0 as i32)) as f32,
+            (z as i32 + (world_z * CHUNK_SIZE.0 as i32)) as f32,
+        );
+
+        let sines = f32::sin(xf * 0.1) + f32::sin(zf * 0.1);
+
+        let n = ((sines / 2. * CHUNK_SIZE.2 as f32).round() as i32) <= y as _;
+        sl3set(&mut blocks, x, y, z, {
+            if n { Block::BRICK } else { Block::AIR }
+        });
+    }
+
+    Chunk { blocks }
+}
+
+pub fn new_map() -> WorldMap {
+    WorldMap {
+        chunks: HashMap::from([((0, 0).into(), new_chunk(0, 0))]),
+    }
+}