Components

src/main.rs

@@ -5,7 +5,7 @@ use crate::config::LogConfig;
 use crate::input::InputState;
 use crate::vulkan::{Game, LinePoint, MeshHandle, VulkanRenderer};
 use crate::vulkan::vs::ty::ObjectUniformData;
-use crate::gameobject::{GameObject, GameObjectHandle};
+use crate::gameobject::{GameObject, GameObjectHandle, Component, TestComponent};
 
 mod vulkan;
 mod input;
@@ -22,6 +22,7 @@ struct TestGame {
     log_config: LogConfig,
     texture_index_counter: usize,
     last_time: f32,
+    components: Vec<Box<dyn Component>>,
 }
 
 impl Game for TestGame {
@@ -35,9 +36,9 @@ impl Game for TestGame {
         let frame_time = time - self.last_time;
 
         let input = &self.input;
-        let objects = &mut self.game_objects;
-        objects.iter_mut().for_each(|game_object| {
-            game_object.get_game_object(renderer).unwrap().update(frame_time, &input);
+        let components = &mut self.components;
+        components.iter_mut().for_each(|component| {
+            component.update(frame_time, &input, renderer);
         });
 
         // User interaction
@@ -45,6 +46,10 @@ impl Game for TestGame {
             renderer.game_data.shutdown = true;
         }
 
+        if self.input.button_just_released("test") {
+            println!("{:?}", self.game_objects[0].get_game_object(renderer).unwrap().position);
+        }
+
         if self.input.button_just_pressed("reload_shaders") {
             renderer.game_data.recreate_pipeline = true;
         }
@@ -54,8 +59,7 @@ impl Game for TestGame {
         }
 
         let light_pos = vec3(f32::sin(time) * 2.0 + 2.0, f32::cos(time) * 2.0 + 2.0, 2.0);
-        self.game_objects[2].get_game_object(renderer).unwrap().set_position(light_pos.into());
-
+        self.game_objects[2].get_game_object(renderer).unwrap().position = light_pos;
 
         self.cam_rotation = self.cam_rotation * Quaternion::from_angle_y(Deg(self.input.get_axis("look_horizontal") * 0.05));
         self.cam_rotation = Quaternion::from_angle_x(Deg(self.input.get_axis("look_vertical") * 0.05)) * self.cam_rotation;
@@ -100,15 +104,22 @@ fn _matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f
 
 impl TestGame {
     fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
+        let mut test_comp = TestComponent { game_objects: vec![] };
+
         let cube_meshes = self.load_gltf(renderer, "models/box.gltf.glb");
         let sphere_meshes = self.load_gltf(renderer, "models/sphere.glb");
 
         let cube = self.add_game_object(renderer, *cube_meshes.first().unwrap(), 0);
-        cube.get_game_object(renderer).unwrap().set_position((3.0, 4.0, 5.0));
+        cube.get_game_object(renderer).unwrap().position = vec3(3.0, 4.0, 5.0);
+        test_comp.game_objects.push(cube.clone());
+
         let sphere = self.add_game_object(renderer, *sphere_meshes.first().unwrap(), 0);
-        sphere.get_game_object(renderer).unwrap().set_position((0.0, 0.0, 0.0));
+        sphere.get_game_object(renderer).unwrap().position = vec3(0.0, 0.0, 0.0);
+
         let light_sphere = self.add_game_object(renderer, *sphere_meshes.first().unwrap(), 0);
-        light_sphere.get_game_object(renderer).unwrap().set_scale((0.1, 0.1, 0.1));
+        light_sphere.get_game_object(renderer).unwrap().scale = vec3(0.1, 0.1, 0.1);
+
+        self.components.push(Box::new(test_comp));
         println!("Game loaded!");
     }
 
@@ -148,7 +159,8 @@ fn main() {
         game_objects: vec![],
         log_config,
         texture_index_counter: 1,
-        last_time: 0.0
+        last_time: 0.0,
+        components: vec![],
     };
 
     let line_count = 30;