Multithread the chunk loader

Cargo.lock

···
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "ab_glyph"
···
  "rand",
  "reqwest",
  "rollgrid",
+ "rusqlite",
  "thiserror 2.0.11",
  "tobj",
  "wasm-bindgen",
···
 ]
 
 [[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
 name = "fastrand"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
 dependencies = [
  "foldhash",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+dependencies = [
+ "hashbrown",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "libsqlite3-sys"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbb8270bb4060bd76c6e96f20c52d80620f1d82a3470885694e41e0f81ef6fe7"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
 name = "linux-raw-sys"
 version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "be0228715d4e911eadcd3df048512222f53fc3df6d4fb5e7e989b7b3a89019d5"
 dependencies = [
  "panicmsg",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37e34486da88d8e051c7c0e23c3f15fd806ea8546260aa2fec247e97242ec143"
+dependencies = [
+ "bitflags 2.8.0",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
 ]
 
 [[package]]

Cargo.toml

···
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rand = "0.9.0"
+rusqlite = { version = "0.34.0", features = ["bundled"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_error_panic_hook = "0.1.6"
···
     "Storage"
 ] }
 reqwest = "0.12"
-instant = { version = "0.1", features = [ "wasm-bindgen" ] }
+instant = { version = "0.1", features = ["wasm-bindgen"] }

src/app.rs

···
+use crate::world::chunk::Chunk;
 use crate::{
+    concurrency::GameThread,
     gfx::{Gfx, GfxBuilder, MaybeGfx},
     gui::EguiRenderer,
-    world::map::new,
-    world::World,
+    world::{map::new, World},
+    ConnectionOnlyOnNative,
 };
-use glam::dvec2;
-use std::sync::Arc;
+use glam::{dvec2, ivec3, IVec3};
+use std::sync::mpsc::channel;
+use std::sync::{Arc, Mutex, TryLockResult};
+use std::thread::spawn;
 use winit::{
     application::ApplicationHandler,
     event::{DeviceEvent, DeviceId, ElementState, KeyEvent, WindowEvent},
···
     gfx_state: MaybeGfx,
     window: Option<Arc<Window>>,
     egui: Option<EguiRenderer>,
-    world: World,
+    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) -> Self {
+    pub fn new(event_loop: &EventLoop<Gfx>, title: &str, mut conn: rusqlite::Connection) -> Self {
+        let world = Arc::new(Mutex::new(World {
+            map: new(),
+            remake: false,
+        }));
         Self {
             window_attributes: Window::default_attributes().with_title(title),
             gfx_state: MaybeGfx::Builder(GfxBuilder::new(event_loop.create_proxy())),
             window: None,
             egui: None,
-            world: World { map: new() },
+            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!");
+
+                        let Ok((x, y, z)) = rx.recv() else {
+                            break;
+                        };
+
+                        let Ok(ref mut w) = w.lock() else {
+                            log::error!("Poisoned mutex?");
+                            break;
+                        };
+
+                        w.map.chunks.reposition(
+                            IVec3::from((x, y, z)).into(),
+                            |_old, new, chunk| {
+                                *chunk =
+                                    Chunk::load(ivec3(new.0, new.1, new.2), &mut conn).unwrap();
+                            },
+                        );
+
+                        w.remake = true;
+                        dbg!(&w.map.chunks.offset());
+                    }
+                });
+
+                GameThread::new(thread, tx)
+            },
             last_render_time: instant::Instant::now(),
+            conn,
         }
     }
 }
···
                     let dt = now - self.last_render_time;
                     self.last_render_time = now;
 
+                    // let mut world = self.world.lock().unwrap();
+
                     window.request_redraw();
-                    match gfx.render(&mut self.egui, window.clone(), &mut self.world, dt) {
+                    match gfx.render(
+                        &mut self.egui,
+                        window.clone(),
+                        self.world.clone(),
+                        &mut self.conn,
+                        dt,
+                    ) {
                         Ok(_) => {
                             // TODO CITE https://github.com/kaphula/winit-egui-wgpu-template/blob/master/src/app.rs#L3
-                            gfx.update(&mut self.world, dt);
+                            gfx.update(
+                                self.world.clone(),
+                                &mut self.conn,
+                                &mut self.world_update_thread,
+                                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::model::DrawLight;
 use crate::world::chunk::{sl3get, sl3get_opt, CHUNK_SIZE};
···
     gui::EguiRenderer,
     world::map::{BlockKind, WorldMap},
     world::World,
-    Instance, InstanceRaw,
+    ConnectionOnlyOnNative, Instance, InstanceRaw,
 };
 use egui_wgpu::ScreenDescriptor;
 use glam::{uvec2, vec3, IVec3, Quat, Vec3};
 use std::f32::consts::{FRAC_PI_2, FRAC_PI_3};
-use std::sync::Arc;
+use std::sync::mpsc::{channel, Receiver, Sender};
+use std::sync::{Arc, Mutex};
 use wgpu::util::DeviceExt;
 use wgpu::BindingResource;
 use winit::{
···
     pub model: model::Model,
     pub instances: Vec<Instance>,
     pub instance_buffer: wgpu::Buffer,
-    pub remake: bool,
 }
 
 pub struct LightState {
···
                 model: obj_model,
                 instances,
                 instance_buffer,
-                remake: false,
             },
             light: LightState {
                 object: light,
···
             });
         self.object.instances = instances;
         self.object.instance_buffer = instance_buffer;
-        self.object.remake = false;
     }
 
     pub(crate) fn render(
         &mut self,
         egui: &mut Option<EguiRenderer>,
         window: Arc<Window>,
-        world: &mut World,
+        world: Arc<Mutex<World>>,
+        conn: &mut ConnectionOnlyOnNative,
         dt: instant::Duration,
     ) -> Result<(), wgpu::SurfaceError> {
         let output = self.surface.get_current_texture()?;
···
             };
             egui.begin_frame(&window);
 
-            egui.update(self, world, dt);
+            egui.update(self, &mut world.lock().unwrap(), conn, dt);
 
             egui.end_frame_and_draw(
                 &self.device,
···
         Ok(())
     }
 
-    pub fn update(&mut self, world: &mut World, dt: instant::Duration) {
+    pub fn update(
+        &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,
-            &mut self.object.remake,
+            world.clone(),
+            conn,
+            thread,
         );
         self.camera
             .uniform
···
             bytemuck::cast_slice(&[self.light.uniform]),
         );
 
+        let mut world = world.lock().unwrap();
         // Object update
-        if self.object.remake {
+        if world.remake {
             self.update_instance_buf(&world.map);
+            world.remake = 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};
 use instant::Duration;
 use itertools::Itertools;
+use std::sync::{Arc, Mutex};
 use winit::{
     dpi::PhysicalPosition,
     event::{ElementState, MouseScrollDelta},
     keyboard::KeyCode,
 };
-
-use crate::world::{chunk::Chunk, map::RENDER_GRID_SIZE, World};
-
 
 const MAX_CAMERA_PITCH: f32 = (3.0 / std::f32::consts::PI) - 0.0001;
 
···
             scroll: 0.,
             speed,
             sensitivity,
-            load_chunks: true,
+            load_chunks: false,
         }
     }
 
···
         &mut self,
         camera: &mut Camera,
         duration: Duration,
-        world: &mut World,
-        remake: &mut bool,
+        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();
···
 
         if self.load_chunks {
             const BLOCK_UNIT_SIZE: i32 = 32;
-            let chunk_relative = IVec3::from(
-                (camera.position.x as i32 / BLOCK_UNIT_SIZE,
+            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));
-            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)).unwrap();
-                    });
-                *remake = true;
+            )) + IVec3::splat(-(RENDER_GRID_SIZE as i32 / 2));
+            if chunk_relative != world.lock().unwrap().map.chunks.offset().into() {
+                let IVec3 { x, y, z } = chunk_relative;
+                world_thread.tx.send((x, y, z)).unwrap();
             }
+
+            // 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;
···
         self.view_proj = projection.mat4() * camera.mat4();
     }
 }
-

src/gui.rs

···
+use std::thread;
+
 use egui::{FontId, RichText};
 use egui_winit::EventResponse;
 use glam::ivec3;
···
         chunk::{Chunk, ChunkScramble},
         World,
     },
+    ConnectionOnlyOnNative,
 };
 
 const FPS_AVG_WINDOW: usize = 120;
···
         self.frame_started = false;
     }
 
-    pub fn update(&mut self, gfx: &mut Gfx, world: &mut World, dt: instant::Duration) {
+    pub fn update(
+        &mut self,
+        gfx: &mut Gfx,
+        world: &mut World,
+        conn: &mut ConnectionOnlyOnNative,
+        dt: instant::Duration,
+    ) {
         let mut scale_factor = self.scale_factor;
         let (mut chunk_x, mut chunk_y, mut chunk_z) = self.chunk_influence;
         let (mut grid_x, mut grid_y, mut grid_z) = world.map.chunks.offset();
···
                 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 grid_x).speed(0.1).update_while_editing(false));
+                    ui.add_enabled(
+                        !camera_load,
+                        egui::DragValue::new(&mut grid_x)
+                            .speed(0.1)
+                            .update_while_editing(false),
+                    );
                     ui.label("x ");
 
-                    ui.add_enabled(!camera_load, egui::DragValue::new(&mut grid_y).speed(0.1).update_while_editing(false));
+                    ui.add_enabled(
+                        !camera_load,
+                        egui::DragValue::new(&mut grid_y)
+                            .speed(0.1)
+                            .update_while_editing(false),
+                    );
                     ui.label("y ");
 
-                    ui.add_enabled(!camera_load, egui::DragValue::new(&mut grid_z).speed(0.1).update_while_editing(false));
+                    ui.add_enabled(
+                        !camera_load,
+                        egui::DragValue::new(&mut grid_z)
+                            .speed(0.1)
+                            .update_while_editing(false),
+                    );
                     ui.label("z.");
                 });
 
···
                     if ui.button("Random").clicked() {
                         let c = Chunk::generate(pos, ChunkScramble::Random);
                         world.map.chunks.set(pos.into(), c);
-                        gfx.object.remake = true;
+                        world.remake = true;
                     }
                     if ui.button("Normal").clicked() {
                         let c = Chunk::generate(pos, ChunkScramble::Normal);
                         world.map.chunks.set(pos.into(), c);
-                        gfx.object.remake = true;
+                        world.remake = true;
                     }
                     if ui.button("Inverse").clicked() {
                         let c = Chunk::generate(pos, ChunkScramble::Inverse);
                         world.map.chunks.set(pos.into(), c);
-                        gfx.object.remake = true;
+                        world.remake = true;
                     }
                 });
 
···
 
                 ui.horizontal(|ui| {
                     if ui.button("Save").clicked() {
-                        world.save().unwrap();
+                        world.save(conn).unwrap();
                     }
                 });
             });
···
 
         gfx.camera.controller.load_chunks = camera_load;
 
-        if !camera_load {
-            if (grid_x, grid_y, grid_z) != world.map.chunks.offset() {
-                world
-                    .map
-                    .chunks
-                    .reposition((grid_x, grid_y, grid_z), |_old, new, chunk| {
-                        *chunk = Chunk::load(ivec3(new.0, new.1, new.2)).unwrap();
-                    });
-                gfx.object.remake = true;
-            }
+        if !camera_load && (grid_x, grid_y, grid_z) != world.map.chunks.offset() {
+            world
+                .map
+                .chunks
+                .reposition((grid_x, grid_y, grid_z), |_old, new, chunk| {
+                    *chunk = Chunk::load(ivec3(new.0, new.1, new.2), conn).unwrap();
+                });
+            world.remake = true;
         }
-
-
     }
 }

src/lib.rs

···
 #![allow(rust_analyzer::inactive_code)]
 
 mod app;
+mod concurrency;
 mod gfx;
 mod gui;
 mod world;
···
     rotation: Quat,
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+type ConnectionOnlyOnNative = rusqlite::Connection;
+
+#[cfg(target_arch = "wasm32")]
+type ConnectionOnlyOnNative = ();
+
 impl Instance {
     fn to_raw(&self) -> InstanceRaw {
         InstanceRaw {
···
 
 impl InstanceRaw {
     fn desc() -> wgpu::VertexBufferLayout<'static> {
-
-
         wgpu::VertexBufferLayout {
             array_stride: size_of::<InstanceRaw>() as wgpu::BufferAddress,
             step_mode: wgpu::VertexStepMode::Instance,
···
     init_logger();
 
     log::info!("Hello world!");
-    preload_chunk_cache();
+    // preload_chunk_cache();
+
+    let conn = rusqlite::Connection::open("./save.sqlite").unwrap();
+    conn.execute(
+        r#"
+        CREATE TABLE IF NOT EXISTS chunks (
+            x INTEGER,
+            y INTEGER,
+            z INTEGER,
+            data BLOB,
+            PRIMARY KEY (x,y,z)
+        )
+    "#,
+        (),
+    )
+    .unwrap();
+
     let event_loop = EventLoop::with_user_event().build().unwrap_throw();
 
-    let mut app = app::Application::new(&event_loop, "BL0CK");
+    let mut app = app::Application::new(&event_loop, "BL0CK", conn);
     event_loop.run_app(&mut app).unwrap();
 }

src/world.rs

···
-pub(crate) mod map;
-pub(crate) mod encoded;
 pub(crate) mod chunk;
+pub(crate) mod encoded;
+pub(crate) mod map;
 
 use bincode::{Decode, Encode};
 
+use crate::ConnectionOnlyOnNative;
 use glam::ivec3;
 use map::WorldMap;
 
 #[derive(Encode, Decode)]
 pub struct World {
     pub map: WorldMap,
+    pub remake: bool,
 }
 impl World {
-    pub fn save(&self) -> Result<(), Box<dyn std::error::Error>> {
-        for ((x,y,z), chunk) in self.map.chunks.iter() {
-            chunk.save(ivec3(x,y,z))?;
+    pub fn save(
+        &self,
+        conn: &mut ConnectionOnlyOnNative,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        for ((x, y, z), chunk) in self.map.chunks.iter() {
+            chunk.save(ivec3(x, y, z), conn)?;
         }
         Ok(())
     }

src/world/chunk.rs

···
 use super::map::BlockKind;
+use crate::ConnectionOnlyOnNative;
 use bincode::{Decode, Encode};
 use glam::{ivec3, IVec3};
 use itertools::Itertools;
···
         Chunk::generate_callback(method)(map_pos)
     }
 
-    pub fn save(&self, map_pos: IVec3) -> Result<(), Box<dyn std::error::Error>> {
+    pub fn save(
+        &self,
+        map_pos: IVec3,
+        conn: &mut ConnectionOnlyOnNative,
+    ) -> Result<(), 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));
-            let mut file = File::create(&file_path).unwrap();
-            let encoded = bincode::encode_into_std_write(self, &mut file, config)?;
+            let encoded = bincode::encode_to_vec(self, config)?;
 
-            log::warn!("Wrote to file {file_name} with {encoded}b.");
+            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::{BASE64_STANDARD, Engine};
+            use base64::prelude::{Engine, BASE64_STANDARD};
             let encoded = bincode::encode_to_vec(self, config)?;
             let encoded = BASE64_STANDARD.encode(encoded);
 
···
         }
         Ok(())
     }
-    fn load_from_file(map_pos: IVec3) -> Result<Option<Chunk>, Box<dyn std::error::Error>> {
+    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();
+            // 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 decoded = bincode::decode_from_std_read(&mut file, config)?;
+            let (decoded, _) = bincode::decode_from_slice(i.as_slice(), config)?;
 
-                Ok(Some(decoded))
-            } else {
-                log::warn!("Chunk not loaded!");
-                Ok(None)
-            }
+            Ok(Some(decoded))
+            // } else {
+            //     log::warn!("Chunk not loaded!");
+            //     Ok(None)
+            // }
         }
         #[cfg(target_arch = "wasm32")]
         {
-            use base64::prelude::{BASE64_STANDARD, Engine};
+            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)?;
···
         }
     }
 
-    pub fn load(map_pos: IVec3) -> Result<Chunk, Box<dyn std::error::Error>> {
+    pub fn load(
+        map_pos: IVec3,
+        conn: &mut ConnectionOnlyOnNative,
+    ) -> Result<Chunk, Box<dyn std::error::Error>> {
         #[cfg(not(target_arch = "wasm32"))]
         let cached = CHUNK_FILE_CACHE.lock().unwrap().contains_key(&map_pos);
         #[cfg(target_arch = "wasm32")]
         let cached = false;
 
         if cached {
-            log::warn!("Cache hit!");
+            // 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)? {
+            // 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)?;
+                    new_chunk.save(map_pos, conn)?;
                     new_chunk
                 }
             };
···
         let _3diter = itertools::iproduct!(-r..r, -r..r, -r..r);
 
         for (x, y, z) in _3diter {
-            let _ = Chunk::load(ivec3(x, y, z));
+            // let _ = Chunk::load(ivec3(x, y, z));
         }
     }
 }

src/world/map.rs

···
 use super::chunk::Chunk;
+use crate::ConnectionOnlyOnNative;
 use bincode::{Decode, Encode};
 use glam::ivec3;
 #[cfg(not(target_arch = "wasm32"))]
···
 pub struct WorldMap {
     pub chunks: RollGrid3D<Chunk>,
 }
-pub(crate) const RENDER_GRID_SIZE: usize = 15;
+pub(crate) const RENDER_GRID_SIZE: usize = 9;
 pub fn new() -> WorldMap {
+    let mut conn = rusqlite::Connection::open("./save.sqlite").unwrap();
+
     WorldMap {
         chunks: RollGrid3D::new(
             (
···
                 RENDER_GRID_SIZE as _,
             ),
             (0, 0, 0),
-            |(x, y, z)| Chunk::load(ivec3(x, y, z)).unwrap(),
+            |(x, y, z)| Chunk::load(ivec3(x, y, z), &mut conn).unwrap(),
         ),
     }
 }