Most of the compute side is mocked up and compiling.

src/vkprocessor.rs

@@ -10,6 +10,8 @@ use winit::{Window};
 use crate::util::compute_kernel::ComputeKernel;
 use crate::util::compute_image::ComputeImage;
 use crate::canvas::{Canvas, CanvasFrame};
+use crate::compu_wip::{CompuState, ComputeFrame};
+use vulkano::image::ImageUsage;
 
 pub struct VkProcessor<'a> {
 
@@ -29,6 +31,8 @@ pub struct VkProcessor<'a> {
 
     swapchain_recreate_needed: bool,
 
+    compute_state: CompuState,
+
     capabilities: Capabilities,
     canvas: Canvas,
 }
@@ -36,6 +40,45 @@ 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();
 
@@ -68,6 +111,7 @@ impl<'a> VkProcessor<'a> {
             swapchain: None,
             swapchain_images: None,
             swapchain_recreate_needed: false,
+            compute_state: CompuState::new(),
             capabilities: capabilities.clone(),
             canvas: Canvas::new(queue, device, physical, capabilities),
         }
@@ -153,8 +197,12 @@ impl<'a> VkProcessor<'a> {
         surface: &'a Arc<Surface<Window>>,
         mut frame_future: Box<dyn GpuFuture>,
         canvas_frame: CanvasFrame,
+        compute_frame: ComputeFrame,
     ) -> Box<dyn GpuFuture> {
 
+
+
+        //
         self.canvas.draw(canvas_frame);
         self.canvas.allocate_vertex_buffers(self.device.clone());