From 711e6789696c8d300d6034a4756179088c90d06f Mon Sep 17 00:00:00 2001 From: mitchellhansen Date: Thu, 5 Sep 2019 23:26:25 -0700 Subject: [PATCH] That's it. Fifo present mode halts until the next time the screen is refreshed. Mailbox will replace the lined up image if the refresh period has not been reached --- src/main.rs | 3 +- src/vkprocessor.rs | 90 +++++++++++++++++++++++++++------------------- 2 files changed, 55 insertions(+), 38 deletions(-) diff --git a/src/main.rs b/src/main.rs index 4f10dfa4..4c28b958 100644 --- a/src/main.rs +++ b/src/main.rs @@ -175,7 +175,8 @@ fn main() { //canvas.draw(&compu_sprite1); { let g = hprof::enter("Run"); - (frame_future) = processor.run(&surface, frame_future, + processor.run(&surface, + //frame_future, canvas, compu_frame); } diff --git a/src/vkprocessor.rs b/src/vkprocessor.rs index 1a964fe7..8161ba0a 100644 --- a/src/vkprocessor.rs +++ b/src/vkprocessor.rs @@ -15,6 +15,7 @@ use crate::canvas::{CanvasState, CanvasTextureHandle, CanvasShaderHandle, Canvas use crate::canvas_frame::CanvasFrame; use crate::compu_kernel::{CompuKernel, CompuKernelHandle}; use crate::compu_buffer::{CompuBuffers, CompuBufferHandle}; +use std::time::Duration; pub struct VkProcessor<'a> { // Vulkan state fields @@ -94,7 +95,7 @@ impl<'a> VkProcessor<'a> { Swapchain::new(self.device.clone(), surface.clone(), - capabilities.min_image_count, // number of attachment images + capabilities.min_image_count + 10, // number of attachment images format, initial_dimensions, 1, // Layers @@ -102,13 +103,12 @@ impl<'a> VkProcessor<'a> { &self.queue, SurfaceTransform::Identity, alpha, - PresentMode::Fifo, true, None).unwrap() + PresentMode::Mailbox, true, None).unwrap() }; self.swapchain = Some(swapchain); self.swapchain_images = Some(images); } - // On resizes we have to recreate the swapchain pub fn recreate_swapchain(&mut self, surface: &'a Arc>) { let dimensions = if let Some(dimensions) = surface.window().get_inner_size() { @@ -174,22 +174,23 @@ impl<'a> VkProcessor<'a> { pub fn run(&mut self, surface: &'a Arc>, - mut frame_future: Box, + // mut frame_future: Box, canvas_frame: CanvasFrame, compute_frame: CompuFrame, ) - -> Box { + // -> Box { + { { let g = hprof::enter("Waiting at queue"); self.queue.wait(); } - + let g = hprof::enter("Frame buffer, future, swapchain recreate"); let mut framebuffers = self.canvas.window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone()); // The docs said to call this on each loop. - frame_future.cleanup_finished(); + // frame_future.cleanup_finished(); // Whenever the window resizes we need to recreate everything dependent on the window size. // In this example that includes the swapchain, the framebuffers and the dynamic state viewport. @@ -200,18 +201,29 @@ impl<'a> VkProcessor<'a> { self.swapchain_recreate_needed = false; } + // This function can block if no image is available. The parameter is an optional timeout // after which the function call will return an error. - let (image_num, acquire_future) = match vulkano::swapchain::acquire_next_image(self.swapchain.clone().unwrap().clone(), None) { - Ok(r) => r, - Err(AcquireError::OutOfDate) => { - self.swapchain_recreate_needed = true; - return Box::new(sync::now(self.device.clone())) as Box<_>; - } - Err(err) => panic!("{:?}", err) - }; + let (image_num, acquire_future) = + match vulkano::swapchain::acquire_next_image( + self.swapchain.clone().unwrap().clone(), + //Some(Duration::from_millis(3)), + None, + ) { + Ok(r) => r, + Err(AcquireError::OutOfDate) => { + self.swapchain_recreate_needed = true; + //return Box::new(sync::now(self.device.clone())) as Box<_>; + return; + } + Err(err) => panic!("{:?}", err) + }; + drop(g); + + let g = hprof::enter("Joining the future"); + // let future = frame_future.join(acquire_future); + drop(g); - let future = frame_future.join(acquire_future); { let g = hprof::enter("Canvas creates GPU buffers"); // take the canvas frame and create the vertex buffers @@ -224,36 +236,41 @@ impl<'a> VkProcessor<'a> { let g = hprof::enter("Push compute commands to command buffer"); // Add the compute commands - // let mut command_buffer = self.compute_state.compute_commands(compute_frame, command_buffer, &self.canvas); + // let mut command_buffer = self.compute_state.compute_commands(compute_frame, command_buffer, &self.canvas); drop(g); let g = hprof::enter("Push draw commands to command buffer"); // Add the draw commands - // let mut command_buffer = self.canvas.draw_commands(command_buffer, framebuffers, image_num); + // let mut command_buffer = self.canvas.draw_commands(command_buffer, framebuffers, image_num); drop(g); // And build let command_buffer = command_buffer.build().unwrap(); // Wait on the previous frame, then execute the command buffer and present the image - - let future = future //frame_future.join(acquire_future) - .then_execute(self.queue.clone(), command_buffer).unwrap() - .then_swapchain_present(self.queue.clone(), self.swapchain.clone().unwrap().clone(), image_num) - .then_signal_fence_and_flush(); - - match future { - Ok(future) => { - (Box::new(future) as Box<_>) - } - Err(FlushError::OutOfDate) => { - self.swapchain_recreate_needed = true; - (Box::new(sync::now(self.device.clone())) as Box<_>) - } - Err(e) => { - println!("{:?}", e); - (Box::new(sync::now(self.device.clone())) as Box<_>) - } + { + let g = hprof::enter("Mussing with the frame future"); + + //let future = future //frame_future.join(acquire_future) + let future = sync::now(self.device.clone()) + .then_execute(self.queue.clone(), command_buffer).unwrap() + .then_swapchain_present(self.queue.clone(), self.swapchain.clone().unwrap().clone(), image_num) + .then_signal_fence_and_flush(); + future.unwrap().wait(None).unwrap(); + +// match future { +// Ok(future) => { +// (Box::new(future) as Box<_>) +// } +// Err(FlushError::OutOfDate) => { +// self.swapchain_recreate_needed = true; +// (Box::new(sync::now(self.device.clone())) as Box<_>) +// } +// Err(e) => { +// println!("{:?}", e); +// (Box::new(sync::now(self.device.clone())) as Box<_>) +// } +// } } } } @@ -275,4 +292,3 @@ impl<'a> VkProcessor<'a> { -