starting to hook up the compute frame translation.

src/vkprocessor.rs

@@ -40,45 +40,6 @@ pub struct VkProcessor<'a> {
 
 impl<'a> VkProcessor<'a> {
 
-    pub fn preload_textures(&mut self) {
-
-    }
-    pub fn preload_kernels(&mut self) {
-
-    }
-    pub fn preload_shaders(&mut self) {
-
-    }
-
-    pub fn get_texture_handle(&self, texture_name: String) -> Option<Arc<u32>> {
-        None
-    }
-    pub fn get_kernel_handle(&self, kernel_name: String) -> Option<Arc<u32>> {
-        None
-    }
-    pub fn get_shader_handle(&self, shader_name: String) -> Option<Arc<u32>> {
-        None
-    }
-
-    pub fn new_swap_image(&mut self, dimensions: (u32, u32)) -> Arc<u32> {
-        let mut usage = ImageUsage::none();
-        usage.transfer_destination = true;
-        usage.storage = true;
-
-        self.canvas.create_image(dimensions, usage)
-    }
-
-    pub fn new_compute_buffer(&mut self, data: Vec<u8>, dimensions: (u32, u32), stride: u32) -> Arc<u32> {
-        self.compute_state.new_compute_buffer(data, dimensions, stride, self.device.clone())
-    }
-    pub fn read_compute_buffer(&mut self, handle: Arc<u32>) -> Vec<u8> {
-        self.compute_state.read_compute_buffer(handle)
-    }
-    pub fn write_compute_buffer(&self, handle: Arc<u32>, data: Vec<u8>) {
-        self.compute_state.write_compute_buffer(handle, data)
-    }
-
-
     pub fn new(instance: &'a Arc<Instance>, surface: &'a Arc<Surface<Window>>) -> VkProcessor<'a> {
         let physical = PhysicalDevice::enumerate(instance).next().unwrap();
 
@@ -117,10 +78,6 @@ impl<'a> VkProcessor<'a> {
         }
     }
 
-    pub fn compile_kernel(&mut self, filename: String) {
-        self.compute_kernel = Some(ComputeKernel::new(filename, self.device.clone()));
-    }
-
     pub fn create_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) {
         let (mut swapchain, images) = {
             let capabilities = surface.capabilities(self.physical).unwrap();
@@ -177,20 +134,45 @@ impl<'a> VkProcessor<'a> {
         self.swapchain_images = Some(new_images);
     }
 
-    pub fn load_compute_image(&mut self, image_filename: String) {
-        self.compute_image = Some(ComputeImage::new(self.device.clone(), image_filename.clone()));
+    pub fn preload_textures(&mut self) {
+        self.canvas.load_texture_from_filename(String::from("funky-bird.jpg"));
+    }
+    pub fn preload_kernels(&mut self) {
+
+    }
+    pub fn preload_shaders(&mut self) {
+
     }
 
-    pub fn load_textures(&mut self, image_filename: String) {
-        self.canvas.load_texture_from_filename(image_filename.clone());
+    pub fn get_texture_handle(&self, texture_name: String) -> Option<Arc<u32>> {
+        None
+    }
+    pub fn get_kernel_handle(&self, kernel_name: String) -> Option<Arc<u32>> {
+        None
+    }
+    pub fn get_shader_handle(&self, shader_name: String) -> Option<Arc<u32>> {
+        None
     }
 
-    pub fn save_edges_image(&mut self) {
-        self.compute_image.clone().unwrap().clone().save_image();
+    // Create a new image which has the transfer usage
+    pub fn new_swap_image(&mut self, dimensions: (u32, u32)) -> Arc<u32> {
+        let mut usage = ImageUsage::none();
+        usage.transfer_destination = true;
+        usage.storage = true;
+
+        self.canvas.create_image(dimensions, usage)
     }
 
-    pub fn get_canvas(&mut self) -> &Canvas {
-        &self.canvas
+    pub fn new_compute_buffer(&mut self, data: Vec<u8>, dimensions: (u32, u32), stride: u32) -> Arc<u32> {
+        self.compute_state.new_compute_buffer(data, dimensions, stride, self.device.clone())
+    }
+
+    pub fn read_compute_buffer(&mut self, handle: Arc<u32>) -> Vec<u8> {
+        self.compute_state.read_compute_buffer(handle)
+    }
+
+    pub fn write_compute_buffer(&self, handle: Arc<u32>, data: Vec<u8>) {
+        self.compute_state.write_compute_buffer(handle, data)
     }
 
     pub fn run(&mut self,
@@ -198,13 +180,14 @@ impl<'a> VkProcessor<'a> {
         mut frame_future: Box<dyn GpuFuture>,
         canvas_frame: CanvasFrame,
         compute_frame: ComputeFrame,
-    ) -> Box<dyn GpuFuture> {
+    )
+        -> Box<dyn GpuFuture> {
 
-
-
-        //
+        // take the canvas frame and create the vertex buffers
         self.canvas.draw(canvas_frame);
-        self.canvas.allocate_vertex_buffers(self.device.clone());
+
+        // ditto with the compuframe
+        self.compute_state.compute(compute_frame);
 
         let mut framebuffers =
             self.canvas.window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone());