Most of the compute side is mocked up and compiling.

src/canvas.rs

@@ -9,7 +9,7 @@ use vulkano::device::{Device, Queue};
 use vulkano::instance::PhysicalDevice;
 use vulkano::image::immutable::ImmutableImage;
 use crate::util::shader_kernels::ShaderKernels;
-use vulkano::image::{Dimensions, ImageAccess, ImageDimensions, SwapchainImage};
+use vulkano::image::{Dimensions, ImageAccess, ImageDimensions, SwapchainImage, ImageUsage, AttachmentImage};
 use vulkano::sampler::{Sampler, SamplerAddressMode, MipmapMode, Filter};
 use vulkano::descriptor::DescriptorSet;
 use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
@@ -82,7 +82,8 @@ impl Vertex for ColoredVertex2D {
 pub trait Drawable {
     fn get_vertices(&self) -> Vec<(f32, f32)>;
     fn get_color(&self) -> (f32, f32, f32, f32);
-    fn get_texture_id(&self) -> Option<String>;
+    fn get_texture_handle(&self) -> Option<Arc<u32>>;
+    fn get_image_handle(&self) -> Option<Arc<u32>>;
 }
 
 // Need three types of shaders. Solid, Textured, Compute
@@ -95,7 +96,7 @@ pub enum ShaderType {
 
 pub struct CanvasFrame {
     colored_drawables : Vec<ColoredVertex2D>,
-    textured_drawables: HashMap<String, Vec<Vertex2D>>,
+    textured_drawables: HashMap<Arc<u32>, Vec<Vertex2D>>,
 }
 
 impl CanvasFrame {
@@ -110,10 +111,10 @@ impl CanvasFrame {
     // After done using this, need to call allocated vertex buffers
     pub fn draw(&mut self, drawable: &dyn Drawable) {
 
-        match drawable.get_texture_id() {
+        match drawable.get_texture_handle() {
             Some(id) => {
                 self.textured_drawables
-                    .entry(id)
+                    .entry(id.clone())
                     .or_insert(Vec::new())
                     .extend(drawable.get_vertices().iter().map(|n|
                         Vertex2D {
@@ -145,8 +146,8 @@ pub struct Canvas {
     colored_drawables : Vec<ColoredVertex2D>,
     colored_vertex_buffer: Vec<Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
 
-    textured_drawables: HashMap<String, Vec<Vertex2D>>,
-    textured_vertex_buffer: HashMap<String, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
+    textured_drawables: HashMap<Arc<u32>, Vec<Vertex2D>>,
+    textured_vertex_buffer: HashMap<Arc<u32>, Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync)>>,
 
     shader_kernels: HashMap<ShaderType, ShaderKernels>,
 
@@ -154,9 +155,13 @@ pub struct Canvas {
 
     dynamic_state: DynamicState,
 
+    image_buffers: Vec<std::sync::Arc<vulkano::image::attachment::AttachmentImage>>,
+    image_buffer_handles: Vec<Arc<u32>>,
+
     // Looks like we gotta hold onto the queue for managing textures
     queue: Arc<Queue>,
-    sampler: Arc<Sampler>
+    sampler: Arc<Sampler>,
+    device: Arc<Device>,
 }
 
 
@@ -177,6 +182,7 @@ impl Canvas {
          ]);
 
         Canvas {
+
             colored_drawables: vec![],
             colored_vertex_buffer: vec![],
 
@@ -188,6 +194,10 @@ impl Canvas {
 
             dynamic_state: DynamicState { line_width: None, viewports: None, scissors: None },
 
+            image_buffers: Vec::new(),
+            image_buffer_handles: Vec::new(),
+
+            device: device.clone(),
             queue: queue.clone(),
             sampler: Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
                                 MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
@@ -196,6 +206,18 @@ impl Canvas {
         }
     }
 
+    pub fn create_image(&mut self, dimensions: (u32, u32), usage: ImageUsage) -> Arc<u32> {
+        self.image_buffers.push(
+            AttachmentImage::with_usage(
+                self.device.clone(),
+                [dimensions.0, dimensions.1],
+                Format::R8G8B8A8Uint,
+                usage).unwrap());
+        let id = Arc::new(self.image_buffers.len() as u32);
+        self.image_buffer_handles.push(id.clone());
+        id
+    }
+
     // TODO Handle file not found gracefully
     fn get_texture_from_file(&self, image_filename: String) -> Arc<ImmutableImage<Format>> {