in the midst of a very messy refactor of the way i build the command buffer

src/vkprocessor.rs

@@ -35,22 +35,19 @@ use vulkano::image::immutable::ImmutableImage;
 use vulkano::image::attachment::AttachmentImage;
 use vulkano::image::{Dimensions, ImageUsage, ImageAccess, ImageDimensions};
 use vulkano::format::Format;
+use vulkano::format::ClearValue;
 use vulkano::sampler::{Sampler, Filter, MipmapMode, SamplerAddressMode};
 use image::flat::NormalForm::ColumnMajorPacked;
 
-mod compute_kernel;
-use crate::vkprocessor::compute_kernel::ComputeKernel;
-
-mod shader_kernels;
-use crate::vkprocessor::shader_kernels::ShaderKernels;
-
-mod compute_image;
-use crate::vkprocessor::compute_image::ComputeImage;
+use crate::util::compute_kernel::ComputeKernel;
+use crate::util::shader_kernels::ShaderKernels;
+use crate::util::compute_image::ComputeImage;
 
 use vulkano::descriptor::descriptor::DescriptorDesc;
 use crate::vertex_2d::ColoredVertex2D;
 
 
+
 /// This method is called once during initialization, then again whenever the window is resized
 fn window_size_dependent_setup(
     images: &[Arc<SwapchainImage<Window>>],
@@ -100,6 +97,8 @@ pub struct VkProcessor<'a> {
     pub swapchain: Option<Arc<Swapchain<Window>>>,
     pub swapchain_images: Option<Vec<Arc<SwapchainImage<Window>>>>,
 
+    swapchain_recreate_needed: bool,
+
 }
 
 
@@ -137,7 +136,8 @@ impl<'a> VkProcessor<'a> {
             textures: vec![],
             compute_image: None,
             swapchain: None,
-            swapchain_images: None
+            swapchain_images: None,
+            swapchain_recreate_needed: false,
         }
     }
 
@@ -176,7 +176,7 @@ impl<'a> VkProcessor<'a> {
 
             Swapchain::new(self.device.clone(),
                            surface.clone(),
-                           capabilities.min_image_count,
+                           capabilities.min_image_count, // number of attachment images
                            format,
                            initial_dimensions,
                            1, // Layers
@@ -287,6 +287,9 @@ impl<'a> VkProcessor<'a> {
             ].iter().cloned()).unwrap()
         };
 
+
+
+
         self.vertex_buffer = Some(vertex_buffer);
         self.vertex_buffer2 = Some(vertex_buffer2);
 
@@ -344,20 +347,17 @@ impl<'a> VkProcessor<'a> {
                                                            self.shader_kernels.clone().unwrap().render_pass.clone(),
                                                            &mut self.dynamic_state);
 
-        let mut recreate_swapchain = false;
-
         // The docs said to call this on each loop.
         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.
-        if recreate_swapchain {
+        if self.swapchain_recreate_needed {
             self.recreate_swapchain(surface);
             framebuffers = window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone(),
                                                        self.shader_kernels.clone().unwrap().render_pass.clone(),
-                                                       //self.render_pass.clone().unwrap().clone(),
                                                        &mut self.dynamic_state);
-            recreate_swapchain = false;
+            self.swapchain_recreate_needed = false;
         }
 
         // This function can block if no image is available. The parameter is an optional timeout
@@ -365,15 +365,14 @@ impl<'a> VkProcessor<'a> {
         let (image_num, acquire_future) = match vulkano::swapchain::acquire_next_image(self.swapchain.clone().unwrap().clone(), None) {
             Ok(r) => r,
             Err(AcquireError::OutOfDate) => {
-                recreate_swapchain = true;
-                //continue;
-                panic!("Weird thing");
+                self.swapchain_recreate_needed = true;
+                return Box::new(sync::now(self.device.clone())) as Box<_>;
             }
             Err(err) => panic!("{:?}", err)
         };
 
         // Specify the color to clear the framebuffer with i.e. blue
-        let clear_values = vec!([0.0, 0.0, 1.0, 1.0].into());
+        let clear_values = vec!(ClearValue::Float([0.0, 0.0, 1.0, 1.0]));
 
         let mut v = Vec::new();
         v.push(self.vertex_buffer.clone().unwrap().clone());
@@ -383,7 +382,7 @@ impl<'a> VkProcessor<'a> {
 
         let xy = self.compute_image.clone().unwrap().get_size();
 
-        let command_buffer =
+        let mut command_buffer =
             AutoCommandBufferBuilder::primary_one_time_submit(self.device.clone(), self.queue.family())
                 .unwrap()
 
@@ -395,19 +394,20 @@ impl<'a> VkProcessor<'a> {
                 .copy_buffer_to_image(self.compute_image.clone().unwrap().clone().rw_buffers.get(0).unwrap().clone(),
                     self.compute_image.clone().unwrap().clone().get_swap_buffer().clone()).unwrap()
 
-                .begin_render_pass(framebuffers[image_num].clone(), false, clear_values)
+                .begin_render_pass(framebuffers[image_num].clone(), false, clear_values.clone())
                 .unwrap()
 
                 .draw(self.shader_kernels.clone().unwrap().get_pipeline(),
                       &self.dynamic_state.clone(), v,
                       vec![self.get_image_set()], ())
-                .unwrap()
+                .unwrap();
 
-                .draw(self.shader_kernels.clone().unwrap().get_pipeline(),
+        command_buffer = command_buffer.draw(self.shader_kernels.clone().unwrap().get_pipeline(),
                       &self.dynamic_state.clone(), v2,
                       vec![self.get_gui_image_set()], ())
-                .unwrap()
+                .unwrap();
 
+        let command_buffer = command_buffer
                 .end_render_pass()
                 .unwrap()
 
@@ -424,7 +424,7 @@ impl<'a> VkProcessor<'a> {
                 (Box::new(future) as Box<_>)
             }
             Err(FlushError::OutOfDate) => {
-                recreate_swapchain = true;
+                self.swapchain_recreate_needed = true;
                 (Box::new(sync::now(self.device.clone())) as Box<_>)
             }
             Err(e) => {