Debug UI chunk mutation, flush inst. buffer

Cargo.lock

···
  "getrandom 0.2.15",
  "once_cell",
  "version_check",
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
···
  "itertools",
  "log",
  "pollster",
+ "rand",
  "reqwest",
  "thiserror 2.0.11",
  "tobj",
···
  "quote",
  "syn",
 ]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "byteorder-lite"
···
 checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3"
 
 [[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy 0.7.35",
+]
+
+[[package]]
 name = "presser"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "rand"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+ "zerocopy 0.8.16",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b08f3c9802962f7e1b25113931d94f43ed9725bebc59db9d0c3e9a23b67e15ff"
+dependencies = [
+ "getrandom 0.3.1",
+ "zerocopy 0.8.16",
+]
+
+[[package]]
 name = "range-alloc"
 version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
- "zerocopy-derive",
+ "byteorder",
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b8c07a70861ce02bad1607b5753ecb2501f67847b9f9ada7c160fff0ec6300c"
+dependencies = [
+ "zerocopy-derive 0.8.16",
 ]
 
 [[package]]
···
 version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5226bc9a9a9836e7428936cde76bb6b22feea1a8bfdbc0d241136e4d13417e25"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

···
 egui = "0.31"
 egui-wgpu = "0.31"
 egui-winit = { version = "0.31", default-features = false }
+rand = "0.9.0"
 
 [build-dependencies]
 fs_extra = "1.3"

src/gfx.rs

···
     app::WASM_WIN_SIZE,
     gfx::model::Vertex,
     gui::EguiRenderer,
-    map::{sl3get, Block, CHUNK_SIZE},
+    map::{sl3get, Block, WorldMap, CHUNK_SIZE},
     Instance, InstanceRaw,
 };
 
···
     pub model: model::Model,
     pub instances: Vec<Instance>,
     pub instance_buffer: wgpu::Buffer,
+    pub remake: bool,
 }
 
 pub struct LightState {
···
     pub render_pipelines: RenderPipelines,
     pub depth_texture: texture::Texture,
 
+    pub map: WorldMap,
     pub object: ObjectState,
     pub camera: CameraState,
     pub interact: InteractState,
···
         let mut instances = vec![];
 
         const SPACE_BETWEEN: f32 = 2.0;
-        for (coords, chunk) in map.chunks {
+        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
···
             queue,
             surface_config,
             depth_texture,
+            map,
             camera: camera_state,
             interact: InteractState {
                 wireframe: false,
···
                 model: obj_model,
                 instances,
                 instance_buffer,
+                remake: false,
             },
             light: LightState {
                 uniform: light_uniform,
···
         );
     }
 
+    pub fn update_instance_buf(&mut self) {
+        let mut instances = vec![];
+
+        const SPACE_BETWEEN: f32 = 2.0;
+        for (coords, chunk) in &self.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 chunk_offset = coords.as_vec2() * (SPACE_BETWEEN * CHUNK_SIZE.0 as f32);
+
+                    let mapping = |n| SPACE_BETWEEN * (n as f32 - CHUNK_SIZE.0 as f32 / 2.0);
+                    let position = vec3(
+                        mapping(x) + chunk_offset.x,
+                        -mapping(y),
+                        mapping(z) + chunk_offset.y,
+                    );
+
+                    let rotation = Quat::from_axis_angle(Vec3::Y, 0.0);
+
+                    Some(Instance { position, rotation })
+                })
+                .collect::<Vec<_>>();
+
+            instances.append(&mut i);
+        }
+
+        let instance_data = instances.iter().map(Instance::to_raw).collect::<Vec<_>>();
+        let instance_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Instance Buffer"),
+                contents: bytemuck::cast_slice(&instance_data),
+                usage: wgpu::BufferUsages::VERTEX,
+            });
+        self.object.instances = instances;
+        self.object.instance_buffer = instance_buffer;
+        self.object.remake = false;
+    }
+
     pub(crate) fn render(
         &mut self,
         egui: &mut Option<EguiRenderer>,
···
             0,
             bytemuck::cast_slice(&[self.light.uniform]),
         );
+        if self.object.remake {
+            self.update_instance_buf();
+        }
     }
 
     pub fn input(&mut self, event: &WindowEvent, window_size: PhysicalSize<u32>) -> bool {
         self.camera.controller.process_events(event);
-
 
         // Deprecated! Replaced with EGUI debug ui.
         // match event {

src/gui.rs

···
 use egui_winit::EventResponse;
+use glam::{ivec2, IVec2};
 use winit::window::Window;
 
-use crate::gfx::Gfx;
+use crate::{gfx::Gfx, map::{chunk_scramble_dispatch, ChunkScramble}};
 
 pub struct EguiRenderer {
     state: egui_winit::State,
     renderer: egui_wgpu::Renderer,
     frame_started: bool,
     pub scale_factor: f32,
+    pub chunk_influence: (i32, i32),
 }
 
 impl EguiRenderer {
···
             state,
             renderer,
             frame_started: false,
-            scale_factor: 1.0
+            scale_factor: 1.0,
+            chunk_influence: (0,0)
         }
     }
 
···
         let ctx = self.ctx();
 
         let mut scale_factor = self.scale_factor;
+        let (mut chunk_x, mut chunk_z) = self.chunk_influence;
 
         egui::Window::new("Debug Menu")
             .resizable(true)
···
                         scale_factor = (scale_factor + 0.1).min(3.0);
                     }
                 });
+
+                ui.separator();
+
+                ui.horizontal(|ui| {
+                    ui.label("Scramble chunk at...");
+                    ui.add(egui::DragValue::new(&mut chunk_x).speed(0.1));
+                    ui.label("x, ");
+
+                    ui.add(egui::DragValue::new(&mut chunk_z).speed(0.1));
+                    ui.label("z. ");
+                });
+
+                ui.horizontal(|ui| {
+                    if ui.button("Random").clicked() {
+                        let c = chunk_scramble_dispatch(ChunkScramble::Random)(chunk_x,chunk_z);
+                        gfx.map.chunks.insert(ivec2(chunk_x,chunk_z), c);
+                        gfx.object.remake = true;
+                    }
+                    if ui.button("Normal").clicked() {
+                        let c = chunk_scramble_dispatch(ChunkScramble::Normal)(chunk_x,chunk_z);
+                        gfx.map.chunks.insert(ivec2(chunk_x,chunk_z), c);
+                        gfx.object.remake = true;
+                    }
+                    if ui.button("Inverse").clicked() {
+                        let c = chunk_scramble_dispatch(ChunkScramble::Inverse)(chunk_x,chunk_z);
+                        gfx.map.chunks.insert(ivec2(chunk_x,chunk_z), c);
+                        gfx.object.remake = true;
+                    }
+                });
+
             });
 
         self.scale_factor = scale_factor;
+        self.chunk_influence = (chunk_x, chunk_z);
     }
 }

src/map.rs

···
 use glam::{ivec2, IVec2};
+use itertools::Itertools;
+use rand::{distr::{Distribution, StandardUniform}, Rng};
 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 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]
+    sl3[y + CHUNK_SIZE.2 * (z + CHUNK_SIZE.1 * x)]
 }
 pub fn sl3set(sl3: &mut Slice3, x: usize, y: usize, z: usize, new: Block) {
-    sl3[y][z][x] = new;
+    sl3[y + CHUNK_SIZE.2 * (z + CHUNK_SIZE.1 * x)] = new;
 }
 
 pub struct WorldMap {
···
     Brick,
 }
 
+impl Distribution<Block> for StandardUniform {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Block {
+        match rng.random_range(0..=1) {
+            0 => Block::Air,
+            _ => Block::Brick,
+        }
+    }
+}
+
+
 fn new_chunk(world_x: i32, world_z: i32) -> Chunk {
-    let mut blocks = Slice3::default();
+    let blocks = itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2)
+        .map(|(x, z, y)| {
+            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,
+            );
 
-    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 sines = f32::sin(xf * 0.1) + f32::sin(zf * 0.1);
+            // Pretty arbitrary numbers! Just trying to get something interesting
+            let n = (((sines / 4. + 0.5) * CHUNK_SIZE.2 as f32).round() as i32) <= y as _;
 
-        // Pretty arbitrary numbers! Just trying to get something interesting
-        let n = (((sines / 4. + 0.5) * CHUNK_SIZE.2 as f32).round() as i32) <= y as _;
-        sl3set(&mut blocks, x, y, z, {
-            if n { Block::Brick } else { Block::Air }
-        });
-    }
+            if n {
+                Block::Brick
+            } else {
+                Block::Air
+            }
+        })
+        .collect_array()
+        .unwrap();
 
     Chunk { blocks }
 }
 
 pub fn new_map() -> WorldMap {
-
     const INITIAL_GENERATION_SIZE: usize = 11;
-    let iter = (-(INITIAL_GENERATION_SIZE as i32/2)..).take(INITIAL_GENERATION_SIZE);
+    let iter = (-(INITIAL_GENERATION_SIZE as i32 / 2)..).take(INITIAL_GENERATION_SIZE);
 
     let mut chunks = HashMap::new();
 
     for (x, z) in itertools::iproduct!(iter.clone(), iter) {
-        chunks.insert(ivec2(x,z) ,new_chunk(x, z));
+        chunks.insert(ivec2(x, z), new_chunk(x, z));
     }
 
     WorldMap { chunks }
+}
+
+pub fn chunk_scramble_dispatch(method: ChunkScramble) -> fn(i32, i32) -> Chunk {
+    use ChunkScramble as C;
+    match method {
+        C::Normal => new_chunk,
+        C::Inverse => |x, z| Chunk {
+            blocks: new_chunk(x, z)
+                .blocks
+                .iter()
+                .map(|b| match b {
+                    Block::Air => Block::Brick,
+                    Block::Brick => Block::Air,
+                })
+                .collect_array()
+                .unwrap(),
+        },
+        C::Random => |_,_| {
+            Chunk {
+                blocks: rand::rng().random()
+            }
+        }
+    }
+}
+
+pub enum ChunkScramble {
+    Normal,
+    Inverse,
+    Random,
 }