Async chunk loading

Cargo.lock

···
  "rusqlite",
  "thiserror 2.0.17",
  "tobj",
+ "tokio",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
···
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
+name = "signal-hook-registry"
+version = "1.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad"
+dependencies = [
+ "libc",
+]
+
+[[package]]
 name = "simd-adler32"
 version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "bytes",
  "libc",
  "mio",
+ "parking_lot",
  "pin-project-lite",
+ "signal-hook-registry",
  "socket2",
+ "tokio-macros",
  "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]

Cargo.toml

···
 bincode = "2.0.0-RC.3"
 instant = "0.1"
 base64 = "0.22.1"
+tokio = { version = "1", features = ["full"]}
 
 [build-dependencies]
 fs_extra = "1.3"

src/app.rs

···
 use crate::world::chunk::Chunk;
+use crate::world::map::WorldMap;
 use crate::{
-    concurrency::GameThread,
     gfx::{Gfx, GfxBuilder, MaybeGfx},
     gui::EguiRenderer,
     world::World,
···
     window: Option<Arc<Window>>,
     egui: Option<EguiRenderer>,
     world: Arc<Mutex<World>>,
-    world_update_thread: GameThread<(), (i32, i32, i32)>,
     last_render_time: instant::Instant,
     conn: ConnectionOnlyOnNative,
 }
···
 impl Application {
     pub fn new(event_loop: &EventLoop<Gfx>, title: &str, conn: Connection) -> Self {
         let world = Arc::new(Mutex::new(World {
-            map: Default::default(),
+            map: WorldMap::new(),
             dirty: false,
         }));
         Self {
···
             window: None,
             egui: None,
             world: world.clone(),
-            world_update_thread: {
-                let (tx, rx) = channel();
-
-                let thread = spawn(move || {
-                    let w = world;
-                    //let mut conn = rusqlite::Connection::open("./save.sqlite").unwrap();
-
-                    loop {
-                        println!("Looping!");
-
-                        // TODO: Why is this in a separate thread? Analyse.
-                        // This has "temporarily" been disabled in gfx/camera.rs.
-                        let Ok((x, y, z)) = rx.recv() else {
-                            break;
-                        };
-
-                        let Ok(ref mut w) = w.lock() else {
-                            log::error!("Poisoned mutex?");
-                            break;
-                        };
-
-                        w.map.focus = ivec3(x, y, z);
-                        w.dirty = true;
-                    }
-                });
-
-                GameThread::new(thread, tx)
-            },
             last_render_time: instant::Instant::now(),
             conn,
         }
···
                     ) {
                         Ok(_) => {
                             // TODO CITE https://github.com/kaphula/winit-egui-wgpu-template/blob/master/src/app.rs#L3
-                            gfx.update(
-                                self.world.clone(),
-                                &mut self.conn,
-                                &mut self.world_update_thread,
-                                dt,
-                            );
+                            gfx.update(self.world.clone(), &mut self.conn, dt);
                         }
                         Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
                             gfx.resize(window.inner_size());

src/concurrency.rs

···
-use std::sync::mpsc::Sender;
-use std::thread::JoinHandle;
-
-pub struct GameThread<T, U> {
-    pub join_handle: JoinHandle<T>,
-    pub tx: Sender<U>,
-}
-
-impl<T, U> GameThread<T, U> {
-    pub fn new(join_handle: JoinHandle<T>, tx: Sender<U>) -> Self {
-        GameThread { join_handle, tx }
-    }
-
-    // pub fn fulfil(&mut self, join_handle: JoinHandle<T>) {
-    //     self.join_handle = Some(join_handle);
-    // }
-}

src/gfx.rs

···
 mod resources;
 mod texture;
 
-use crate::concurrency::GameThread;
-use crate::gfx::camera::CameraUniform;
+use crate::gfx::camera::{Camera, CameraUniform};
 use crate::gfx::model::DrawLight;
-use crate::world::chunk::{sl3get, sl3get_opt, CHUNK_SIZE};
+use crate::ivec3_product;
+use crate::world::chunk::{sl3get, sl3get_opt, Chunk, CHUNK_SIZE};
 use crate::{
     app::WASM_WIN_SIZE,
     gfx::model::Vertex,
···
 
         // MAP LOAD
 
-        let mut map = crate::world::map::WorldMap::default();
+        let mut map = WorldMap::new();
 
-        let instances = Self::remake_instance_buf(&mut map);
+        let instances = Self::remake_instance_buf(&camera_state.object, &mut map);
 
         let instance_data = instances.iter().map(Instance::to_raw).collect::<Vec<_>>();
         let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
···
         );
     }
 
-    fn remake_instance_buf(map: &mut WorldMap) -> Vec<Instance> {
+    fn remake_instance_buf(camera: &Camera, _map: &mut WorldMap) -> Vec<Instance> {
         let mut instances = vec![];
 
-        const SPACE_BETWEEN: f32 = 2.0;
+        // WGPU Crashes with an empty instance buffer, add a small item out of camera vfar
+        if instances.is_empty() {
+            instances.push(Instance {
+                position: Vec3::splat(9999.),
+                rotation: Quat::from_axis_angle(Vec3::Y, 0.0),
+            })
+        }
+        instances
+    }
 
-        let mut conn = rusqlite::Connection::open("./save.sqlite").unwrap();
+    pub fn update_instance_buf(&mut self, map: &mut WorldMap) {
+        let mut instances = self.object.instances.clone();
+        let camera = &self.camera.object;
 
-        for (coords, chunk) in map.chunks_around_focus(&mut conn, 5).iter() {
-            let _3diter = itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2);
+        const RENDER_RADIUS: i32 = 1;
 
-            let mut i = _3diter
-                .filter_map(|(x, y, z)| {
-                    if let BlockKind::Air = sl3get(&chunk.blocks, x, y, z) {
-                        return None;
-                    }
+        //println!("{:?}", camera.chunk_pos());
 
-                    // lookup if node is surrounded by nodes
-                    let mut do_not_occlude = false;
-                    let mut sum = vec![];
+        let lower = (camera.chunk_pos() - IVec3::splat(RENDER_RADIUS)).with_y(-1);
+        let higher = (camera.chunk_pos() + IVec3::splat(RENDER_RADIUS)).with_y(1);
 
-                    for (x_, y_, z_) in [
-                        (-1_i32, 0_i32, 0_i32),
-                        (1, 0, 0),
-                        (0, -1, 0),
-                        (0, 1, 0),
-                        (0, 0, -1),
-                        (0, 0, 1),
-                    ] {
-                        if x == 0
-                            || y == 0
-                            || z == 0
-                            || x == CHUNK_SIZE.0 - 1
-                            || y == CHUNK_SIZE.2 - 1
-                            || z == CHUNK_SIZE.1 - 1
-                        {
-                            do_not_occlude = true;
-                            break;
-                        }
+        // poke!
+        ivec3_product(lower, higher).for_each(|idx| map.request_chunk_load(idx));
 
-                        let (x, y, z) = (x as i32 + x_, y as i32 + y_, z as i32 + z_);
-                        if x < 0 || y < 0 || z < 0
-                        // || x == CHUNK_SIZE.0 as i32 - 1
-                        // || y == CHUNK_SIZE.2 as i32 - 1
-                        // || z == CHUNK_SIZE.1 as i32 - 1
-                        {
-                            continue;
-                        }
+        while let Ok(idx) = map.response_rx.try_recv() {
+            println!("GFX: got {idx}");
+            let chunk = map.get_chunk(idx).expect("it said it was ready!");
 
-                        if let Some(block) =
-                            sl3get_opt(&chunk.blocks, x as usize, y as usize, z as usize)
-                        {
-                            sum.push(block)
-                        }
-                    }
+            let mut ids = chunk.indices.clone();
+            instances.append(&mut ids);
+        }
+        // while let Some(idx) = map.try_chunk() {
+        // }
 
-                    if !do_not_occlude && sum.iter().all(|b| *b == BlockKind::Brick) {
-                        return None;
-                    }
+        // for (coords, chunk) in map.chunks_around_focus(&mut conn, 5).iter() {
 
-                    let chunk_offset = coords.as_vec3() * (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) + chunk_offset.y,
-                        mapping(z) + chunk_offset.z,
-                    );
-
-                    let rotation = Quat::from_axis_angle(Vec3::Y, 0.0);
-
-                    Some(Instance { position, rotation })
-                })
-                .collect::<Vec<_>>();
-
-            instances.append(&mut i);
-        }
+        // }
 
         // WGPU Crashes with an empty instance buffer, add a small item out of camera vfar
         if instances.is_empty() {
···
                 rotation: Quat::from_axis_angle(Vec3::Y, 0.0),
             })
         }
-        instances
-    }
-
-    pub fn update_instance_buf(&mut self, map: &mut WorldMap) {
-        let instances = Self::remake_instance_buf(map);
 
         let instance_data = instances.iter().map(Instance::to_raw).collect::<Vec<_>>();
         let instance_buffer = self
···
         &mut self,
         world: Arc<Mutex<World>>,
         conn: &mut ConnectionOnlyOnNative,
-        thread: &mut GameThread<(), (i32, i32, i32)>,
         dt: instant::Duration,
     ) {
         // Camera update
-        self.camera.controller.update_camera(
-            &mut self.camera.object,
-            dt,
-            world.clone(),
-            conn,
-            thread,
-        );
+        self.camera
+            .controller
+            .update_camera(&mut self.camera.object, dt, world.clone(), conn);
         self.camera
             .uniform
             .update_view_proj(&self.camera.object, &self.camera.projection);
···
         );
 
         let mut world = world.lock().unwrap();
+        self.update_instance_buf(&mut world.map);
+
         // Object update
         if world.dirty {
-            self.update_instance_buf(&mut world.map);
             world.dirty = false;
         }
     }

src/gfx/camera.rs

···
-use crate::concurrency::GameThread;
 use crate::world::{chunk::Chunk, map::RENDER_GRID_SIZE, World};
 use crate::ConnectionOnlyOnNative;
 use glam::{ivec3, vec3, IVec3, Mat4, Vec2, Vec3, Vec4};
···
             Vec3::Y,
         )
     }
+    pub fn chunk_pos(&self) -> IVec3 {
+        const BLOCK_UNIT_SIZE: i32 = 32;
+        IVec3::from((
+            self.position.x as i32 / BLOCK_UNIT_SIZE,
+            self.position.y as i32 / BLOCK_UNIT_SIZE,
+            self.position.z as i32 / BLOCK_UNIT_SIZE,
+        ))
+    }
 }
 
 pub struct Projection {
···
         duration: Duration,
         world: Arc<Mutex<World>>,
         conn: &mut ConnectionOnlyOnNative,
-        world_thread: &mut GameThread<(), (i32, i32, i32)>,
     ) {
         let dt = duration.as_secs_f32();
         let movement = self.movement.vec3();
···
         camera.yaw += self.rotation.x * self.sensitivity * dt;
         camera.pitch += -self.rotation.y * self.sensitivity * dt;
 
-        if self.load_chunks {
-            const BLOCK_UNIT_SIZE: i32 = 32;
-            let chunk_relative = IVec3::from((
-                camera.position.x as i32 / BLOCK_UNIT_SIZE,
-                camera.position.y as i32 / BLOCK_UNIT_SIZE,
-                camera.position.z as i32 / BLOCK_UNIT_SIZE,
-            )) + IVec3::splat(-(RENDER_GRID_SIZE as i32 / 2));
-            let mut world = world.lock().unwrap();
-            if chunk_relative != world.map.focus {
-                // This is a stupid way to do threading.
-                // world_thread.tx.send((x, y, z)).unwrap();
+        // if self.load_chunks {
+        //     const BLOCK_UNIT_SIZE: i32 = 32;
+        //     let chunk_relative = IVec3::from((
+        //         camera.position.x as i32 / BLOCK_UNIT_SIZE,
+        //         camera.position.y as i32 / BLOCK_UNIT_SIZE,
+        //         camera.position.z as i32 / BLOCK_UNIT_SIZE,
+        //     )) + IVec3::splat(-(RENDER_GRID_SIZE as i32 / 2));
+        //     let mut world = world.lock().unwrap();
+        //     if chunk_relative != world.map.focus {
+        //         // This is a stupid way to do threading.
+        //         // world_thread.tx.send((x, y, z)).unwrap();
 
-                world.map.focus = chunk_relative;
-                world.dirty = true;
-            }
+        //         world.map.focus = chunk_relative;
+        //         world.dirty = true;
+        //     }
 
-            // if chunk_relative != world.map.chunks.offset().into() {
-            //     world.map.chunks.reposition(
-            //         (IVec3::from(chunk_relative)).into(),
-            //         |_old, new, chunk| {
-            //             *chunk = Chunk::load(ivec3(new.0, new.1, new.2), conn).unwrap();
-            //         },
-            //     );
-            //     *remake = true;
-            // }
-        }
+        //     // if chunk_relative != world.map.chunks.offset().into() {
+        //     //     world.map.chunks.reposition(
+        //     //         (IVec3::from(chunk_relative)).into(),
+        //     //         |_old, new, chunk| {
+        //     //             *chunk = Chunk::load(ivec3(new.0, new.1, new.2), conn).unwrap();
+        //     //         },
+        //     //     );
+        //     //     *remake = true;
+        //     // }
+        // }
 
         self.rotation = Vec2::ZERO;
 

src/gui.rs

···
     ) {
         let mut scale_factor = self.scale_factor;
         let (mut chunk_x, mut chunk_y, mut chunk_z) = self.chunk_influence;
-        let mut map_focus = world.map.focus;
         let mut camera_load = gfx.camera.controller.load_chunks;
 
         let dt = dt.as_secs_f32();
···
                 ui.heading("World toys...");
 
                 ui.checkbox(&mut camera_load, "Camera position loads chunks");
-                ui.label("Move chunk window... ");
-                ui.horizontal(|ui| {
-                    ui.add_enabled(
-                        !camera_load,
-                        egui::DragValue::new(&mut map_focus.x)
-                            .speed(0.1)
-                            .update_while_editing(false),
-                    );
-                    ui.label("x ");
+                // ui.label("Move chunk window... ");
+                // ui.horizontal(|ui| {
+                // ui.add_enabled(
+                // !camera_load,
+                // egui::DragValue::new(&mut map_focus.x)
+                // .speed(0.1)
+                // .update_while_editing(false),
+                // );
+                // ui.label("x ");
 
-                    ui.add_enabled(
-                        !camera_load,
-                        egui::DragValue::new(&mut map_focus.y)
-                            .speed(0.1)
-                            .update_while_editing(false),
-                    );
-                    ui.label("y ");
+                // ui.add_enabled(
+                // !camera_load,
+                // egui::DragValue::new(&mut map_focus.y)
+                // .speed(0.1)
+                // .update_while_editing(false),
+                // );
+                // ui.label("y ");
 
-                    ui.add_enabled(
-                        !camera_load,
-                        egui::DragValue::new(&mut map_focus.z)
-                            .speed(0.1)
-                            .update_while_editing(false),
-                    );
-                    ui.label("z.");
-                });
+                // ui.add_enabled(
+                // !camera_load,
+                // egui::DragValue::new(&mut map_focus.z)
+                // .speed(0.1)
+                // .update_while_editing(false),
+                // );
+                // ui.label("z.");
+                // });
 
                 ui.separator();
                 ui.horizontal(|ui| {
···
                         };
 
                         if let Some(chunk) = c {
-                            world.map.chunks.insert(pos, chunk);
-                            world.dirty = true;
+                            // world.map.chunks.insert(pos, chunk);
+                            // world.dirty = true;
+                            todo!("asdf")
                         }
                     }
                 });
···
         self.chunk_influence = (chunk_x, chunk_y, chunk_z);
 
         gfx.camera.controller.load_chunks = camera_load;
-
-        // If map focus has moved in tick, then:
-        if !camera_load && map_focus != world.map.focus {
-            world.dirty = true;
-        }
     }
 }

src/lib.rs

···
 #![allow(rust_analyzer::inactive_code)]
 
 mod app;
-mod concurrency;
 mod gfx;
 mod gui;
 mod world;
 
-use glam::{Mat3, Quat, Vec3};
+use glam::{ivec3, IVec3, Mat3, Quat, Vec3};
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::UnwrapThrowExt;
 use winit::event_loop::EventLoop;
 use world::chunk::preload_chunk_cache;
 
+#[derive(Copy, Clone, Debug)]
 struct Instance {
     position: Vec3,
     rotation: Quat,
···
     let mut app = app::Application::new(&event_loop, "BL0CK", conn);
     event_loop.run_app(&mut app).unwrap();
 }
+
+fn ivec3_product(lower: IVec3, higher: IVec3) -> impl Iterator<Item = IVec3> {
+    let IVec3 {
+        x: ax,
+        y: ay,
+        z: az,
+    } = lower;
+    let IVec3 {
+        x: bx,
+        y: by,
+        z: bz,
+    } = higher;
+    itertools::iproduct!(ax..=bx, ay..=by, az..=bz).map(|(i, j, k)| ivec3(i, j, k))
+}

src/main.rs

···
 use bl0ck::run;
 
-fn main() {
-    pollster::block_on(run())
+#[tokio::main]
+async fn main() {
+    run().await
 }

src/world.rs

···
         &self,
         conn: &mut ConnectionOnlyOnNative,
     ) -> Result<(), Box<dyn std::error::Error>> {
-        self.map.save(conn)?;
+        // self.map.save(conn)?;
+        todo!("save");
         Ok(())
     }
 }

src/world/chunk.rs

···
 use super::map::BlockKind;
-use crate::ConnectionOnlyOnNative;
+use crate::{ConnectionOnlyOnNative, Instance};
 use bincode::{Decode, Encode};
-use glam::{ivec3, IVec3};
+use glam::{ivec3, vec3, IVec3, Quat, Vec3};
 use itertools::Itertools;
 use std::sync::Mutex;
 use std::{
···
     Random,
 }
 
-#[derive(Copy, Clone, Encode, Decode)]
+#[derive(Clone)]
 pub struct Chunk {
     pub blocks: Slice3,
+    pub indices: Vec<Instance>,
 }
 
 impl Chunk {
+    fn indices(blocks: Slice3, idx: IVec3) -> Vec<Instance> {
+        let _3diter = itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2);
+
+        _3diter
+            .filter_map(|(x, y, z)| {
+                if let BlockKind::Air = sl3get(&blocks, x, y, z) {
+                    return None;
+                }
+
+                // lookup if node is surrounded by nodes
+                let mut do_not_occlude = false;
+                let mut sum = vec![];
+
+                for (x_, y_, z_) in [
+                    (-1_i32, 0_i32, 0_i32),
+                    (1, 0, 0),
+                    (0, -1, 0),
+                    (0, 1, 0),
+                    (0, 0, -1),
+                    (0, 0, 1),
+                ] {
+                    if x == 0
+                        || y == 0
+                        || z == 0
+                        || x == CHUNK_SIZE.0 - 1
+                        || y == CHUNK_SIZE.2 - 1
+                        || z == CHUNK_SIZE.1 - 1
+                    {
+                        do_not_occlude = true;
+                        break;
+                    }
+
+                    let (x, y, z) = (x as i32 + x_, y as i32 + y_, z as i32 + z_);
+                    if x < 0 || y < 0 || z < 0
+                    // || x == CHUNK_SIZE.0 as i32 - 1
+                    // || y == CHUNK_SIZE.2 as i32 - 1
+                    // || z == CHUNK_SIZE.1 as i32 - 1
+                    {
+                        continue;
+                    }
+
+                    if let Some(block) = sl3get_opt(&blocks, x as usize, y as usize, z as usize) {
+                        sum.push(block)
+                    }
+                }
+
+                if !do_not_occlude && sum.iter().all(|b| *b == BlockKind::Brick) {
+                    return None;
+                }
+                const SPACE_BETWEEN: f32 = 2.0;
+
+                let chunk_offset = idx.as_vec3() * (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) + chunk_offset.y,
+                    mapping(z) + chunk_offset.z,
+                );
+
+                let rotation = Quat::from_axis_angle(Vec3::Y, 0.0);
+
+                Some(Instance { position, rotation })
+            })
+            .collect::<Vec<_>>()
+    }
+
     fn generate_normal(world_pos: IVec3) -> Chunk {
         let blocks = itertools::iproduct!(0..CHUNK_SIZE.0, 0..CHUNK_SIZE.1, 0..CHUNK_SIZE.2)
             .map(|(x, z, y)| {
···
             .collect_array()
             .unwrap();
 
-        Chunk { blocks }
+        Chunk {
+            blocks,
+            indices: Chunk::indices(blocks, world_pos),
+        }
     }
 
     fn generate_callback(method: ChunkScramble) -> fn(IVec3) -> Chunk {
         use ChunkScramble as C;
         match method {
             C::Normal => Chunk::generate_normal,
-            C::Inverse => |p| Chunk {
-                blocks: Chunk::generate_normal(p)
+            C::Inverse => |p| {
+                let blocks = Chunk::generate_normal(p)
                     .blocks
                     .iter()
                     .map(|b| match b {
···
                         BlockKind::Brick => BlockKind::Air,
                     })
                     .collect_array()
-                    .unwrap(),
+                    .unwrap();
+                Chunk {
+                    blocks,
+                    indices: Chunk::indices(blocks, p),
+                }
             },
-            C::Random => |_| Chunk {
+            C::Random => |p| {
                 #[cfg(not(target_arch = "wasm32"))]
-                blocks: {
+                let blocks = {
                     use rand::Rng;
                     rand::rng().random()
-                },
-                #[cfg(target_arch = "wasm32")]
-                blocks: { panic!("i hate the web") },
+                };
+
+                Chunk {
+                    blocks,
+                    indices: Chunk::indices(blocks, p),
+                }
             },
         }
     }
···
         Chunk::generate_callback(method)(map_pos)
     }
 
-    pub fn save(
-        &self,
-        map_pos: IVec3,
-        conn: &mut ConnectionOnlyOnNative,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let config = bincode::config::standard();
+    //  pub fn save(
+    //      &self,
+    //      map_pos: IVec3,
+    //      conn: &mut ConnectionOnlyOnNative,
+    //  ) -> Result<(), Box<dyn std::error::Error>> {
+    //      let config = bincode::config::standard();
 
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let encoded = bincode::encode_to_vec(self, config)?;
+    //      #[cfg(not(target_arch = "wasm32"))]
+    //      {
+    //          let encoded = bincode::encode_to_vec(self, config)?;
 
-            let mut stmt = conn.prepare_cached(
-                r#"
-                INSERT INTO chunks (x,y,z,data)
-                VALUES (?,?,?,?)
-            "#,
-            )?;
-            stmt.insert((map_pos.x, map_pos.y, map_pos.z, encoded))?;
-        }
+    //          let mut stmt = conn.prepare_cached(
+    //              r#"
+    //              INSERT INTO chunks (x,y,z,data)
+    //              VALUES (?,?,?,?)
+    //          "#,
+    //          )?;
+    //          stmt.insert((map_pos.x, map_pos.y, map_pos.z, encoded))?;
+    //      }
 
-        // We are going to use LocalStorage for web. I don't like it either.
-        #[cfg(target_arch = "wasm32")]
-        {
-            use base64::prelude::{Engine, BASE64_STANDARD};
-            let encoded = bincode::encode_to_vec(self, config)?;
-            let encoded = BASE64_STANDARD.encode(encoded);
+    //      // We are going to use LocalStorage for web. I don't like it either.
+    //      #[cfg(target_arch = "wasm32")]
+    //      {
+    //          use base64::prelude::{Engine, BASE64_STANDARD};
+    //          let encoded = bincode::encode_to_vec(self, config)?;
+    //          let encoded = BASE64_STANDARD.encode(encoded);
 
-            let store = web_sys::window().unwrap().local_storage().unwrap().unwrap();
-            store.set(&file_name, &encoded);
-        }
-        Ok(())
-    }
-    fn load_from_file(
-        map_pos: IVec3,
-        conn: &mut ConnectionOnlyOnNative,
-    ) -> Result<Option<Chunk>, Box<dyn std::error::Error>> {
-        let config = bincode::config::standard();
-        let file_hash = calculate_hash(&map_pos);
-        let file_name = format!("chunk_{}.bl0ck", file_hash);
+    //          let store = web_sys::window().unwrap().local_storage().unwrap().unwrap();
+    //          store.set(&file_name, &encoded);
+    //      }
+    //      Ok(())
+    //  }
+    // fn load_from_file(
+    //     map_pos: IVec3,
+    //     conn: &mut ConnectionOnlyOnNative,
+    // ) -> Result<Option<Chunk>, Box<dyn std::error::Error>> {
+    //     let config = bincode::config::standard();
+    //     let file_hash = calculate_hash(&map_pos);
+    //     let file_name = format!("chunk_{}.bl0ck", file_hash);
 
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            // let file_path = Path::new("./save/chunk/").join(Path::new(&file_name));
-            // if file_path.exists() {
-            // log::warn!("Load Chunk!");
-            // let mut file = File::open(file_path).unwrap();
+    //     #[cfg(not(target_arch = "wasm32"))]
+    //     {
+    //         // let file_path = Path::new("./save/chunk/").join(Path::new(&file_name));
+    //         // if file_path.exists() {
+    //         // log::warn!("Load Chunk!");
+    //         // let mut file = File::open(file_path).unwrap();
 
-            let mut stmt = conn.prepare_cached(
-                r#"
-                SELECT (data) from chunks
-                WHERE (x,y,z) == (?,?,?)
-            "#,
-            )?;
-            let i: Vec<u8> =
-                match stmt.query_row((map_pos.x, map_pos.y, map_pos.z), |f| f.get("data")) {
-                    Ok(x) => x,
-                    Err(rusqlite::Error::QueryReturnedNoRows) => {
-                        return Ok(None);
-                    }
-                    Err(e) => {
-                        return Err(e.into());
-                    }
-                };
+    //         let mut stmt = conn.prepare_cached(
+    //             r#"
+    //             SELECT (data) from chunks
+    //             WHERE (x,y,z) == (?,?,?)
+    //         "#,
+    //         )?;
+    //         let i: Vec<u8> =
+    //             match stmt.query_row((map_pos.x, map_pos.y, map_pos.z), |f| f.get("data")) {
+    //                 Ok(x) => x,
+    //                 Err(rusqlite::Error::QueryReturnedNoRows) => {
+    //                     return Ok(None);
+    //                 }
+    //                 Err(e) => {
+    //                     return Err(e.into());
+    //                 }
+    //             };
 
-            let (decoded, _) = bincode::decode_from_slice(i.as_slice(), config)?;
+    //         let (decoded, _) = bincode::decode_from_slice(i.as_slice(), config)?;
 
-            Ok(Some(decoded))
-            // } else {
-            //     log::warn!("Chunk not loaded!");
-            //     Ok(None)
-            // }
-        }
-        #[cfg(target_arch = "wasm32")]
-        {
-            use base64::prelude::{Engine, BASE64_STANDARD};
-            let store = web_sys::window().unwrap().local_storage().unwrap().unwrap();
-            if let Ok(Some(s)) = store.get(&file_name) {
-                let s = BASE64_STANDARD.decode(s)?;
-                let (decoded, _) = bincode::decode_from_slice(&s[..], config)?;
+    //         Ok(Some(decoded))
+    //         // } else {
+    //         //     log::warn!("Chunk not loaded!");
+    //         //     Ok(None)
+    //         // }
+    //     }
+    //     #[cfg(target_arch = "wasm32")]
+    //     {
+    //         use base64::prelude::{Engine, BASE64_STANDARD};
+    //         let store = web_sys::window().unwrap().local_storage().unwrap().unwrap();
+    //         if let Ok(Some(s)) = store.get(&file_name) {
+    //             let s = BASE64_STANDARD.decode(s)?;
+    //             let (decoded, _) = bincode::decode_from_slice(&s[..], config)?;
 
-                Ok(Some(decoded))
-            } else {
-                Ok(None)
-            }
-        }
-    }
+    //             Ok(Some(decoded))
+    //         } else {
+    //             Ok(None)
+    //         }
+    //     }
+    // }
 
     pub fn load(
         map_pos: IVec3,
···
         #[cfg(target_arch = "wasm32")]
         let cached = false;
 
-        if cached {
-            // log::warn!("Cache hit!");
-            #[cfg(not(target_arch = "wasm32"))]
-            return Ok(CHUNK_FILE_CACHE.lock().unwrap()[&map_pos]);
-            #[cfg(target_arch = "wasm32")]
-            return unreachable!();
-        } else {
-            // log::warn!("Cache miss!");
-            let chunk = match Chunk::load_from_file(map_pos, conn)? {
-                Some(chunk) => chunk,
-                None => {
-                    let new_chunk = Chunk::generate(map_pos, ChunkScramble::Normal);
-                    new_chunk.save(map_pos, conn)?;
-                    new_chunk
-                }
-            };
-            #[cfg(not(target_arch = "wasm32"))]
-            CHUNK_FILE_CACHE.lock().unwrap().insert(map_pos, chunk);
-            Ok(chunk)
-        }
+        let chunk = Chunk::generate(map_pos, ChunkScramble::Normal);
+        Ok(chunk)
+
+        // if cached {
+        //     // log::warn!("Cache hit!");
+        //     #[cfg(not(target_arch = "wasm32"))]
+        //     //return Ok(CHUNK_FILE_CACHE.lock().unwrap()[&map_pos]);
+        //     #[cfg(target_arch = "wasm32")]
+        //     return unreachable!();
+        // } else {
+        // }
     }
 }
 

src/world/map.rs

···
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    sync::{mpsc::Receiver, Arc, RwLock},
+    time::Duration,
+};
 
 use crate::ConnectionOnlyOnNative;
 
···
     Rng,
 };
 use rusqlite::Connection;
+use tokio::{
+    sync::mpsc::{error::TryRecvError, unbounded_channel, UnboundedReceiver, UnboundedSender},
+    time::sleep,
+};
 
 #[derive(Copy, Clone, Default, Encode, Decode, PartialEq)]
 #[repr(u32)]
···
     }
 }
 
-#[derive(Default)]
+enum LoadNotify {
+    Loaded(IVec3),
+}
+
 pub struct WorldMap {
-    pub chunks: HashMap<IVec3, Chunk>,
-    pub focus: IVec3,
+    chunk_cache: Arc<RwLock<HashMap<IVec3, Chunk>>>,
+    request_tx: UnboundedSender<IVec3>,
+    pub response_rx: Receiver<IVec3>,
 }
 
 impl WorldMap {
-    pub fn chunks_around_focus(
-        &mut self,
-        conn: &mut Connection,
-        radius: i32,
-    ) -> Vec<(IVec3, Chunk)> {
-        let IVec3 { x, y, z } = self.focus - radius;
-        let IVec3 {
-            x: xp,
-            y: yp,
-            z: zp,
-        } = self.focus + radius;
+    pub fn new() -> Self {
+        let (request_tx, mut request_rx) = unbounded_channel::<IVec3>();
+        let (response_tx, response_rx) = std::sync::mpsc::channel::<IVec3>();
+        let chunk_cache = Arc::new(RwLock::new(HashMap::<IVec3, Chunk>::new()));
+
+        let cache_handle = chunk_cache.clone();
+        tokio::spawn(async move {
+            let mut conn = rusqlite::Connection::open("./save.sqlite").unwrap();
+
+            while let Some(index) = request_rx.recv().await {
+                sleep(Duration::from_millis(100)).await;
+                //println!("idx {index}!");
+
+                // load chunk i guess.
+
+                // Already cached, don't bother.
+                if cache_handle.read().expect("poisoned").contains_key(&index) {
+                    println!("MAP: cache hit");
+                    continue;
+                }
+                println!("MAP: got {index}");
+
+                let chunk = Chunk::load(index, &mut conn).expect("oh no.");
+
+                cache_handle.write().expect("poisoned").insert(index, chunk);
+                response_tx.send(index).expect("channel killed");
+            }
+        });
+
+        Self {
+            chunk_cache,
+            request_tx,
+            response_rx,
+        }
+    }
 
-        itertools::iproduct!(x..=xp, y..=yp, z..=zp)
-            .map(|(i, j, k)| {
-                let index = ivec3(i, j, k);
-                (index, self.fetch_chunk(conn, index))
-            })
-            .collect()
+    pub fn get_chunk(&mut self, index: IVec3) -> Option<Chunk> {
+        self.request_chunk_load(index);
+        let cache = self.chunk_cache.read().expect("poisoned");
+        cache.get(&index).cloned()
     }
 
-    fn fetch_chunk(&mut self, conn: &mut Connection, index: IVec3) -> Chunk {
-        let cnk = self.chunks.entry(index);
-        let cnk = cnk.or_insert_with(|| Chunk::load(index, conn).unwrap()); // This sucks. Asyncing this would be much nicer.
+    // pub fn try_chunk(&mut self) -> Option<IVec3> {
+    //     match self.response_rx.try_recv() {
+    //         Ok(idx) => Some(idx),
+    //         Err(TryRecvError::Empty) => {
+    //             println!("empy");
+    //             None
+    //         }
+    //         Err(_) => panic!("aah!"),
+    //     }
+    // }
 
-        cnk.clone() // This sucks.
+    fn poll_chunk(&mut self, index: IVec3) -> bool {
+        let cache = self.chunk_cache.read().expect("poisoned");
+        cache.contains_key(&index)
     }
 
-    pub fn save(
-        &self,
-        conn: &mut ConnectionOnlyOnNative,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        for (pos, chunk) in self.chunks.clone() {
-            // Eww a clone
-            chunk.save(pos, conn)?;
-        }
-        Ok(())
+    pub fn request_chunk_load(&self, index: IVec3) {
+        let _ = self.request_tx.send(index);
     }
+
+    // pub fn save(
+    //     &self,
+    //     conn: &mut ConnectionOnlyOnNative,
+    // ) -> Result<(), Box<dyn std::error::Error>> {
+    //     for (pos, chunk) in self.chunks.clone() {
+    //         // Eww a clone
+    //         chunk.save(pos, conn)?;
+    //     }
+    //     Ok(())
+    // }
 }
 
 pub(crate) const RENDER_GRID_SIZE: usize = 9;