Modules and stuff

src/game/level.rs

@@ -0,0 +1,91 @@
+use std::{error::Error, io::{BufReader, BufWriter}};
+use std::fs::File;
+
+use serde_derive::{Deserialize, Serialize};
+
+use crate::{vulkan::{MeshHandle, VulkanRenderer, gameobject::GameObjectHandle}};
+use crate::game::TestGame;
+
+#[derive(Debug, Serialize, Deserialize)]
+struct MeshJson {
+    path: String
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct ObjectJson {
+    mesh_index: Option<usize>,
+    position: [f32; 3],
+    rotation: [f32; 4],
+    scale: [f32; 3]
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct LevelJson {
+    meshes: Vec<MeshJson>,
+    objects: Vec<ObjectJson>,
+    player: ObjectJson
+}
+
+pub fn load_level(path: &str, game: &mut TestGame, renderer: &mut VulkanRenderer) -> Result<Vec<GameObjectHandle>, Box<dyn Error>> {
+    let file = File::open(path)?;
+    let reader = BufReader::new(file);
+    let level_json: LevelJson = serde_json::from_reader(reader)?;
+    let meshes: Vec<MeshHandle> = level_json.meshes.iter().map(|json_mesh| {
+        let mesh_handles = game.load_gltf(renderer, &json_mesh.path);
+        // TODO: Add empty parent GO instead of just loading the first mesh
+        mesh_handles[0].clone()
+    }).collect();
+    let objects: Vec<GameObjectHandle> = level_json.objects.iter().filter_map(|json_obj| {
+        // TODO: Parenting
+        if let Some(mesh_index) = json_obj.mesh_index {
+            let mut handle = game.add_game_object(renderer, meshes[mesh_index].clone());
+            let game_object = handle.get_game_object_mut(renderer).unwrap();
+            game_object.position = json_obj.position.into();
+            game_object.rotation = json_obj.rotation.into();
+            game_object.scale = json_obj.scale.into();
+            Some(handle)
+        } else {
+            None
+        }
+    }).collect();
+    game.player.camera.position = level_json.player.position.into();
+    game.player.camera.rotation = level_json.player.rotation.into();
+    Ok(objects)
+}
+
+pub fn save_level(path: &str, game: &mut TestGame, renderer: &mut VulkanRenderer) -> Result<(), Box<dyn Error>> {
+    let meshes = renderer.game_data.meshes.iter().map(|mesh| {
+        MeshJson {
+            path: mesh.original_path.to_string()
+        }
+    }).collect();
+
+    let objects = game.game_objects.iter().map(|game_object_handle| {
+        let game_object = game_object_handle.get_game_object(renderer).unwrap();
+        ObjectJson {
+            mesh_index: Some(game_object_handle.object_index),
+            position: game_object.position.into(),
+            rotation: game_object.rotation.into(),
+            scale: game_object.scale.into()
+        }
+    }).collect();
+
+    let player = ObjectJson {
+        mesh_index: None,
+        position: game.player.camera.position.into(),
+        rotation: game.player.camera.rotation.into(),
+        scale: [1., 1., 1.]
+    };
+    
+    let level_json = LevelJson {
+        meshes,
+        objects,
+        player
+    };
+
+    let file = File::create(path)?;
+    let writer = BufWriter::new(file);
+    serde_json::to_writer_pretty(writer, &level_json)?;
+
+    Ok(())
+}