change drawing event order

src/game/mod.rs

@@ -8,12 +8,12 @@ use player::Player;
 
 use crate::game::entities::{FpsCounter, UiQuad, WorldQuad};
 use crate::text::create_brush;
+use crate::vulkan::pipelines::vs;
 use crate::{config::LogConfig, vulkan};
 use crate::input::InputState;
 use crate::vulkan::{Game, MeshHandle, TextVertex, Vertex, VulkanRenderer};
 use crate::vulkan::gameobject::{GameObject, GameObjectHandle, Updatable};
 use crate::vulkan::mesh;
-use crate::vulkan::pipelines::vs::ty::ObjectUniformData;
 
 pub mod player;
 mod level;
@@ -44,6 +44,7 @@ pub struct TestGame {
     pub last_time: f32,
     pub components: Vec<Box<dyn Updatable>>,
     pub game_state: GameState,
+    pub ubo: vs::ty::ObjectUniformData,
 }
 
 impl Game for TestGame {
@@ -55,7 +56,7 @@ impl Game for TestGame {
         self.input.on_window_event(event);
     }
 
-    fn update(self: &mut Self, renderer: &mut VulkanRenderer) -> ObjectUniformData {
+    fn update(self: &mut Self, renderer: &mut VulkanRenderer) {
         let precise_start = Instant::now();
 
         // Input and timing
@@ -113,10 +114,7 @@ impl Game for TestGame {
         self.last_time = time;
         self.input.frame_end();
 
-        let precise_duration = precise_start.elapsed().as_micros();
-        renderer.game_data.update_perf_counters[renderer.game_data.performance_counter_index] = precise_duration;
-
-        ObjectUniformData {
+        self.ubo = vs::ty::ObjectUniformData {
             view: self.player.camera.view.into(),
             projection: self.player.camera.proj.into(),
             ortho_projection: self.player.camera.ortho_proj.into(),
@@ -127,7 +125,14 @@ impl Game for TestGame {
             _dummy0: [0; 12],
             _dummy1: [0; 4],
             _dummy2: [0; 4],
-        }
+        };
+        
+        let precise_duration = precise_start.elapsed().as_micros();
+        renderer.game_data.update_perf_counters[renderer.game_data.performance_counter_index] = precise_duration;
+    }
+
+    fn get_ubo(&self) -> &vs::ty::ObjectUniformData {
+        &self.ubo
     }
 }
 
@@ -141,7 +146,19 @@ impl TestGame {
             texture_index_counter: 0,
             last_time: 0.0,
             components: vec![],
-            game_state: GameState::new()
+            game_state: GameState::new(),
+            ubo: vs::ty::ObjectUniformData {
+                view: [[0.; 4]; 4],
+                projection: [[0.; 4]; 4],
+                ortho_projection: [[0.; 4]; 4],
+                time: 0.,
+                light_position: [0.; 3],
+                light_directional_rotation: [0.; 3],
+                camera_position: [0.; 3],
+                _dummy0: [0; 12],
+                _dummy1: [0; 4],
+                _dummy2: [0; 4],
+            },
         }
     }
 

src/vulkan/mod.rs

@@ -23,7 +23,7 @@ use winit::event::{Event, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 
 use mesh::CPUMesh;
-use pipelines::{Drawcall};
+use pipelines::Drawcall;
 use pipelines::{DefaultShader, TextShader};
 use pipelines::vs;
 use winit::window::{Window, WindowBuilder};
@@ -31,7 +31,7 @@ use winit::window::{Window, WindowBuilder};
 use crate::config::RenderConfig;
 use crate::vulkan::gameobject::GameObject;
 
-use self::mesh::{CPUVertexList};
+use self::mesh::CPUVertexList;
 
 pub mod pipelines;
 pub mod gameobject;
@@ -78,9 +78,11 @@ pub trait Game {
     /// Returns true if event should be ignored by the vulkan handler
     fn on_window_event(self: &mut Self, event: &Event<()>);
 
-    fn update(self: &mut Self, renderer: &mut VulkanRenderer) -> vs::ty::ObjectUniformData;
+    fn update(self: &mut Self, renderer: &mut VulkanRenderer);
 
     fn get_game_objects(&self) -> &Vec<GameObject>;
+
+    fn get_ubo(&self) -> &vs::ty::ObjectUniformData;
 }
 
 pub struct Mesh<V> {
@@ -315,10 +317,10 @@ impl VulkanRenderer {
         }, events_loop)
     }
 
-    fn create_command_buffer(self: &mut Self, fb_index: usize, uniform_buffer_data: vs::ty::ObjectUniformData, game_objects: &Vec<GameObject>) -> Arc<PrimaryAutoCommandBuffer> {
+    fn create_command_buffer(self: &mut Self, fb_index: usize, uniform_buffer_data: &vs::ty::ObjectUniformData, game_objects: &Vec<GameObject>) -> Arc<PrimaryAutoCommandBuffer> {
         // General setup
         let mut builder = AutoCommandBufferBuilder::primary(self.device.clone(), self.queue.family(), CommandBufferUsage::OneTimeSubmit).unwrap();
-        builder.update_buffer(self.uniform_buffers[fb_index].clone(), Arc::new(uniform_buffer_data)).unwrap();
+        builder.update_buffer(self.uniform_buffers[fb_index].clone(), Arc::new(*uniform_buffer_data)).unwrap();
         if self.render_config.msaa_samples > 0 {
             builder.begin_render_pass(self.framebuffers[fb_index].clone(), SubpassContents::Inline, vec![ClearValue::None, ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
         } else {
@@ -340,7 +342,7 @@ impl VulkanRenderer {
         Arc::new(builder.build().unwrap())
     }
 
-    pub fn render_loop(self: &mut Self, new_ubo: vs::ty::ObjectUniformData, game_objects: &Vec<GameObject>) {
+    pub fn render_loop(self: &mut Self, new_ubo: &vs::ty::ObjectUniformData, game_objects: &Vec<GameObject>) {
         let precise_start = Instant::now();
 
         // cleanup previous frame
@@ -688,13 +690,16 @@ pub fn start_event_loop(mut renderer: VulkanRenderer, mut game: Box<dyn Game>, e
             Event::WindowEvent { event: WindowEvent::Resized(..), .. } => {
                 renderer.recreate_swapchain = true;
             },
-            Event::RedrawEventsCleared => {
-                let ubo = game.update(&mut renderer);
-                renderer.render_loop(ubo, &game.get_game_objects());
+            Event::RedrawRequested(..) => {
+                renderer.render_loop(game.get_ubo(), &game.get_game_objects());
                 renderer.game_data.other_perf_counters[renderer.game_data.performance_counter_index] = renderer.game_data.other_perf_instant.elapsed().as_micros();
                 renderer.game_data.other_perf_instant = Instant::now();
                 renderer.game_data.performance_counter_index = (renderer.game_data.performance_counter_index + 1) % PERF_COUNTER_SIZE;
             },
+            Event::MainEventsCleared => {
+                game.update(&mut renderer);
+                renderer.surface.window().request_redraw();
+            },
             _ => {}
         }
     });