more refactoring, compiles.

src/vkprocessor.rs

@@ -7,11 +7,13 @@ use std::sync::Arc;
 use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError, Capabilities};
 use vulkano::image::swapchain::SwapchainImage;
 use winit::{Window};
-use crate::canvas::{CanvasState, CanvasFrame, ImageHandle};
 use crate::compu_state::CompuState;
 use vulkano::image::ImageUsage;
-use crate::compu_buffer::CompuBufferHandle;
 use crate::compu_frame::CompuFrame;
+use crate::canvas::{CanvasState, CanvasTextureHandle, CanvasShaderHandle, CanvasImageHandle};
+use crate::canvas_frame::CanvasFrame;
+use crate::compu_kernel::{CompuKernel, CompuKernelHandle};
+use crate::compu_buffer::{CompuBuffers, CompuBufferHandle};
 
 pub struct VkProcessor<'a> {
 
@@ -64,8 +66,6 @@ impl<'a> VkProcessor<'a> {
             queue: queue.clone(),
             queues: queues,
             dynamic_state: DynamicState { line_width: None, viewports: None, scissors: None },
-            compute_kernel: None,
-            compute_image: None,
             swapchain: None,
             swapchain_images: None,
             swapchain_recreate_needed: false,
@@ -132,27 +132,27 @@ impl<'a> VkProcessor<'a> {
     }
 
     pub fn preload_textures(&mut self) {
-        self.canvas.load_texture_from_filename(String::from("funky-bird.jpg"));
+        self.canvas.load_texture(String::from("funky-bird.jpg"));
     }
     pub fn preload_kernels(&mut self) {
-
+        self.compute_state.new_kernel(String::from("simple-edge.compute"), self.device.clone());
     }
     pub fn preload_shaders(&mut self) {
 
     }
 
-    pub fn get_texture_handle(&self, texture_name: String) -> Option<Arc<u32>> {
+    pub fn get_texture_handle(&self, texture_name: String) -> Option<Arc<CanvasTextureHandle>> {
         None
     }
-    pub fn get_kernel_handle(&self, kernel_name: String) -> Option<Arc<u32>> {
+    pub fn get_kernel_handle(&self, kernel_name: String) -> Option<Arc<CompuKernelHandle>> {
         None
     }
-    pub fn get_shader_handle(&self, shader_name: String) -> Option<Arc<u32>> {
+    pub fn get_shader_handle(&self, shader_name: String) -> Option<Arc<CanvasShaderHandle>> {
         None
     }
 
     // Create a new image which has the transfer usage
-    pub fn new_swap_image(&mut self, dimensions: (u32, u32)) -> Arc<ImageHandle> {
+    pub fn new_swap_image(&mut self, dimensions: (u32, u32)) -> Arc<CanvasImageHandle> {
         let mut usage = ImageUsage::none();
         usage.transfer_destination = true;
         usage.storage = true;