Saving world to file

src/app/mod.rs

@@ -1,40 +1,53 @@
 mod camera_controller;
+mod player;
 pub mod world;
+use std::time::Instant;
 use crate::renderer::content_view::ContentView;
 use cgmath::{SquareMatrix, Point3, InnerSpace};
 use winit::event::Event;
 use crate::renderer::{camera::CameraTransform};
-use camera_controller::CameraController;
+use player::Player;
 use world::World;
 
+
 pub enum GameState {
     Paused,
     Running
 }
 
 pub struct App {
-    camera_controller: CameraController,
+    player: Player,
     world: World
 }
 
 impl App {
     pub fn new(content: &mut dyn ContentView) -> Self {
         let mut app = Self { 
-            camera_controller: CameraController::new(), 
+            player: Player::new(),
             world: World::new("default".to_string())
         };
 
-        let pos = &Point3{x:0,y:0,z:0};
-        let block = app.world.gen_block(pos);
-        content.write(pos, block);
+        let timer = Instant::now();
+        for x in 0..16 {
+            for z in 0..16 {
+                let pos = &Point3{x,y:0,z};
+                let block = app.world.gen_block(pos);
+                content.write(pos, block);
+            }
+        }
+        println!("Generated in {}", timer.elapsed().as_secs_f32());
+        
+        let timer = Instant::now();
+        app.world.save();
+        println!("Saved in {}", timer.elapsed().as_secs_f32());
 
-        let pos = &Point3{x:1,y:0,z:0};
-        let block = app.world.gen_block(pos);
-        content.write(pos, block);
+        // let pos = &Point3{x:1,y:0,z:0};
+        // let block = app.world.gen_block(pos);
+        // content.write(pos, block);
 
-        let pos = &Point3{x:0,y:0,z:1};
-        let block = app.world.gen_block(pos);
-        content.write(pos, block);
+        // let pos = &Point3{x:0,y:0,z:1};
+        // let block = app.world.gen_block(pos);
+        // content.write(pos, block);
 
         println!("App initialized");
         app
@@ -42,16 +55,16 @@ impl App {
 
     pub fn input(&mut self, event: &Event<()>) {
         // Update camera controller
-        self.camera_controller.handle_input(event);
+        self.player.camera_controller.handle_input(event);
     }
 
     pub fn update_state(&mut self, requested_state: GameState) -> GameState {
         match requested_state {
             GameState::Paused => {
-                self.camera_controller.set_enabled(false);
+                self.player.camera_controller.set_enabled(false);
             }
             GameState::Running => {
-                self.camera_controller.set_enabled(true);
+                self.player.camera_controller.set_enabled(true);
             }
         };
 
@@ -60,6 +73,6 @@ impl App {
     }
 
     pub fn update_camera(&mut self, delta: f32, camera_transform: &mut dyn CameraTransform) {
-        self.camera_controller.update(delta, camera_transform);
+        self.player.camera_controller.update(delta, camera_transform);
     }
 }

src/app/player.rs

@@ -1,8 +1,13 @@
+use super::camera_controller::CameraController;
 
-struct Player {
-    camera_controller: CameraController
+pub struct Player {
+    pub camera_controller: CameraController
 }
 
 impl Player {
-    
+    pub fn new() -> Self {
+        Self {
+            camera_controller: CameraController::new()
+        }
+    }
 }

src/app/world/block.rs

@@ -1,4 +1,7 @@
 use cgmath::Point3;
+use std::iter::FromIterator;
+use std::io::Write;
+use flate2::{write::DeflateEncoder, Compression};
 
 pub const SIZE: usize = 32;
 

src/app/world/chunk.rs

@@ -1,4 +1,9 @@
+use flate2::Compression;
+use flate2::write::DeflateEncoder;
+use byteorder::LittleEndian;
+use byteorder::ByteOrder;
 use cgmath::Point3;
+use std::io::Write;
 use crate::app::world::WorldBlock;
 
 pub const SIZE: u32 = 32;
@@ -30,4 +35,22 @@ impl WorldChunk {
         // Return block reference
         &mut self.blocks[(value-1) as usize]
     }
+
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut bytes = Vec::with_capacity(self.nodes.len()*4 + self.blocks.len()* 32*32*32);
+        
+        // Nodes
+        let mut node_bytes = [0_u8; (SIZE*SIZE*SIZE*4) as usize];
+        LittleEndian::write_u32_into(&self.nodes, &mut node_bytes);
+        bytes.extend(node_bytes.iter());
+
+        // Blocks
+        let mut encoder = DeflateEncoder::new(Vec::new(), Compression::fast());
+        for block in self.blocks.iter() {
+            encoder.write_all(&block.materials).unwrap();
+        }
+        bytes.extend(encoder.finish().unwrap());
+    
+        bytes
+    }
 }

src/app/world/mod.rs

@@ -1,6 +1,10 @@
 mod generator;
 pub mod chunk;
 pub mod block;
+use std::path::PathBuf;
+use std::path::Path;
+use std::io::Write;
+use std::fs;
 use cgmath::Point3;
 use std::collections::HashMap;
 use generator::WorldGen;
@@ -21,6 +25,23 @@ impl World {
         }
     }
 
+    pub fn save(&self) {
+        // Get directory
+        let mut dir = dirs::data_local_dir().unwrap();
+        dir.push("Voxelgame");
+        fs::create_dir_all(&dir).expect("Failed to create directory");
+
+        // Save all chunks
+        for (pos, chunk) in self.chunks.iter() {
+            let bytes = chunk.to_bytes();
+            let filename = format!("chunk_{}_{}_{}.dat", pos.x, pos.y, pos.z);
+            let path: PathBuf = [dir.to_str().unwrap(), &filename].iter().collect();
+            
+            let mut file = fs::File::create(path).expect("Failed to create file");
+            file.write(&bytes).unwrap();
+        }
+    }
+
     pub fn gen_block(&mut self, block_pos: &Point3<u32>) -> &WorldBlock {
         // Split world space to chunk and block space
         let ch_pos = block_pos / chunk::SIZE;

src/renderer/passes/ui.rs

@@ -1,9 +0,0 @@
-use crate::renderer::buffers::Buffers;
-
-pub struct UserInterfacePass {
-    pub pipeline: wgpu::RenderPipeline
-}
-
-impl UserInterfacePass {
-    
-}