Load and save level

src/main.rs

@@ -1,4 +1,7 @@
-use cgmath::{Matrix4, vec3, Vector3, Vector4};
+extern crate serde_json;
+
+use cgmath::{Matrix4, Vector3, Vector4};
+use level::{load_level, save_level};
 use winit::event::Event;
 
 use crate::config::{LogConfig, RenderConfig};
@@ -15,8 +18,9 @@ mod mesh;
 mod gameobject;
 mod player;
 mod pipelines;
+mod level;
 
-struct TestGame {
+pub struct TestGame {
     input: InputState,
     player: Player,
     meshes: Vec<MeshHandle>,
@@ -35,7 +39,7 @@ impl TestGame {
             meshes: vec![],
             game_objects: vec![],
             log_config,
-            texture_index_counter: 1,
+            texture_index_counter: 0,
             last_time: 0.0,
             components: vec![],
         }
@@ -66,7 +70,12 @@ impl Game for TestGame {
         }
 
         if self.input.button_just_released("test") {
-            renderer.game_data.use_line_pipeline = !renderer.game_data.use_line_pipeline;
+            println!("Saving...");
+            save_level("levels/test.lvl", self, renderer).unwrap();
+            println!("Clearing level...");
+            self.clear_level(renderer);
+            println!("Loading...");
+            load_level("levels/test.lvl", self, renderer).unwrap();
         }
 
         if self.input.button_just_pressed("reload_shaders") {
@@ -105,15 +114,9 @@ fn _matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f
 
 impl TestGame {
     fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
-        // let cube = self.add_from_gltf(renderer, "models/box.glb");
-        // cube.get_game_object(renderer).unwrap().position = vec3(3.0, 4.0, 5.0);
-        //
-        // let sphere = self.add_from_gltf(renderer, "models/sphere.glb");
-        // sphere.get_game_object(renderer).unwrap().position = vec3(0.0, 0.0, 0.0);
-
-        let plane = self.add_from_gltf(renderer, "models/plane.glb");
-        plane.get_game_object(renderer).unwrap().position = vec3(0.0, -1.0, 0.0);
-        
+        // let plane_mesh = self.load_gltf(renderer, "models/plane.gltf");
+        // self.add_game_object(renderer, plane_mesh[0].clone());
+        load_level("levels/test.lvl", self, renderer).unwrap();
         println!("Game loaded!");
     }
 
@@ -141,8 +144,9 @@ impl TestGame {
                 index: mesh_id,
                 diffuse_handle: diffuse_id,
                 normal_handle: normal_id,
+                original_path: gltf_path.to_string()
             };
-            self.meshes.push(mesh_handle);
+            self.meshes.push(mesh_handle.clone());
             mesh_handles.push(mesh_handle);
         }
 
@@ -153,16 +157,18 @@ impl TestGame {
         mesh_handles
     }
 
-    fn add_from_gltf(&mut self, renderer: &mut VulkanRenderer, path: &str) -> &mut GameObjectHandle {
-        let meshes = self.load_gltf(renderer, path);
-        self.add_game_object(renderer, *meshes.first().unwrap())
-    }
-
-    fn add_game_object(&mut self, renderer: &mut VulkanRenderer, mesh: MeshHandle) -> &mut GameObjectHandle {
+    fn add_game_object(&mut self, renderer: &mut VulkanRenderer, mesh: MeshHandle) -> GameObjectHandle {
         let obj = GameObject::new(mesh);
         let obj_handle = renderer.add_game_object(obj, 0);
         self.game_objects.push(obj_handle);
-        self.game_objects.last_mut().unwrap()
+        self.game_objects.last().unwrap().clone()
+    }
+
+    fn clear_level(&mut self, renderer: &mut VulkanRenderer) {
+        self.game_objects.clear();
+        self.meshes.clear();
+        self.texture_index_counter = 0;
+        renderer.clear_all();
     }
 }