more documentation. Image base impl

src/vkprocessor.rs

@@ -157,20 +157,25 @@ impl<'a> VkProcessor<'a> {
     pub fn preload_shaders(&mut self) {
         self.canvas.load_shader(String::from("color-passthrough"), self.physical.clone(), self.capabilities.clone());
         self.canvas.load_shader(String::from("simple_texture"), self.physical.clone(), self.capabilities.clone());
+        self.canvas.load_shader(String::from("simple_image"), self.physical.clone(), self.capabilities.clone());
     }
 
-
+    /// O(n) Lookup for the matching texture string
     pub fn get_texture_handle(&self, texture_name: String) -> Option<Arc<CanvasTextureHandle>> {
         self.canvas.get_texture_handle(texture_name)
     }
+
+    /// O(n) Lookup for the matching kernel string
     pub fn get_kernel_handle(&self, kernel_name: String) -> Option<Arc<CompuKernelHandle>> {
         self.compute_state.get_kernel_handle(kernel_name)
     }
+
+    /// O(n) Lookup for the matching shader string
     pub fn get_shader_handle(&self, shader_name: String) -> Option<Arc<CanvasShaderHandle>> {
-        None
+        self.canvas.get_shader_handle(shader_name)
     }
 
-    // Create a new image which has the transfer usage
+    /// Create a new image which has the transfer usage
     pub fn new_swap_image(&mut self, dimensions: (u32, u32)) -> Arc<CanvasImageHandle> {
         let mut usage = ImageUsage::none();
         usage.transfer_destination = true;
@@ -179,14 +184,17 @@ impl<'a> VkProcessor<'a> {
         self.canvas.create_image(dimensions, usage)
     }
 
+    /// Builds a compute buffer and returns it's handle
     pub fn new_compute_buffer(&mut self, data: Vec<u8>, dimensions: (u32, u32), stride: u32) -> Arc<CompuBufferHandle> {
         self.compute_state.new_compute_buffer(data, dimensions, stride, self.device.clone())
     }
 
+    /// Takes a compute buffer handle and returns the read data
     pub fn read_compute_buffer(&mut self, handle: Arc<CompuBufferHandle>) -> Vec<u8> {
         self.compute_state.read_compute_buffer(handle)
     }
 
+    /// Takes a compute buffer handle and writes the received data
     pub fn write_compute_buffer(&self, handle: Arc<CompuBufferHandle>, data: Vec<u8>) {
         self.compute_state.write_compute_buffer(handle, data)
     }