have the api of the compu somewhat figured out. Need to weigh my options on texture, buffer, and image handles and how I'm going to get them from the vkprocessor

src/main.rs

@@ -20,7 +20,7 @@ use winit::dpi::LogicalSize;
 use vulkano_win::VkSurfaceBuild;
 use sprite::Sprite;
 use crate::canvas::CanvasFrame;
-
+use crate::compu_wip::{CompuSprite, ComputeFrame, CompuBuffers, CompuState};
 
 mod util;
 mod slider;
@@ -32,7 +32,7 @@ mod vertex_2d;
 mod vertex_3d;
 mod sprite;
 mod canvas;
-
+mod compu_wip;
 
 /*
 
@@ -123,77 +123,54 @@ So to start with we need to know the compute data which we want to run and the k
 the descriptor set. We also need the XY for the compute run
 
 
-I think I need to keep these kernels in their own Canvas type of structure
-    I want to modify their constants and recompile
-
-
-let comp = Computable::new(device, data, kernel_id)
-
-I have canvas frame. Perhaps I should do something similar for compute
-
-ComputeFrame.add(device, data, kernel_id)
-
-
-
-
-Not sure if I can do this... but inside it could be like
-CompuSprite::new(&mut canvas, kernel);
-
-new(&mut canvas) -> CompuSprite {
-    let img_id = canvas.new_image();
-
-    Canvas {
-        img_id.clone()
-    }
-}
-
-
-
-
-
-I want to be able to chain computes using the same data
-So that would be a different pipeline using the same or similar descriptor set
-
-
-
-
-
-sprite = Sprite::with_texture(Canvas.get_texture_from_file())
-
-(compute, sprite2) = Compute::with_swap_image(Canvas.get_new_image())
-
-
-
-compute load shader -> shader object
-
-compute load buffers -> buffer object
-
-shader object + buffer object + maybe the swap buffer
-    -> command queue
-
-
-
-
-
-
-
-let mut canvas = CanvasFrame::new();
-canvas.draw(&sprite);
-canvas.draw(&sprite2);
-
-
-(frame_future) = processor.run(&surface, frame_future, canvas);
-
-
-
-
-
-
+CompuSprite
+    holds the image handle
+    impl's drawable
+CompuBuffers
+    holds the buffer handles
+    creates the descriptor set?
+CompuState
+    holds the compute buffers
+    holds the compute kernels
+ComputeFrame
+    preserves order of entered elements
+    holds compute buffer ids and their tied kernel ids
+    holds compute buffer ids, their swap image ids and their kernel ids
+    holds compute buffer ids, their swap buffer ids, and their kernel ids
+
+// Creates the compu sprite with an associated image stored in canvas
+let compu_sprite    = CompuSprite::new(&mut canvas)
+
+// Compiles and stores the kernel in CompuState
+// Returns the handle to the stored kernel (immutable at this state probably)
+let KernelID        = ComputeState.new_kernel(kernel_path)
+
+// Pushes the data to the GPU and returns a handle
+let ComputeBuffer_1 = ComputeState.new_compute_buffer(input_data, input_settings)
+
+// One by one, assign the buffers to their kernels for run
+ComputeFrame.add(ComputeBuffer_1, KernelID)
+
+// If the buffer needs to be swapped in first
+ComputeFrame.add_with_buffer_swap(ComputeBuffer_1, ComputeBuffer_2, KernelID)
+
+// If the buffer should be swappd out to an image after it computes
+ComputeFrame.add_with_image_swap(ComputeBuffer_1, compu_sprite, KernelID)
+
+CompuState.compute()
 
 
+// Full example if API:
 
+CompuFrame.add(ComputeBuffer1ID, Kernel1ID)
+CompuFrame.add(ComputeBuffer2ID, Kernel2ID)
+CompuFrame.add_with_image_swap(ComputeBuffer1ID, CompuSprite, KernelID)
 
+CanvasFrame.draw(Sprite1)
+CanvasFrame.draw(Sprite2)
+CanvasFrame.draw(CompuSprite)
 
+vkprocessor.run(CanvasFrame, CompuFrame)
 
 
 
@@ -201,7 +178,6 @@ canvas.draw(&sprite2);
 */
 
 
-
 fn main() {
 
     let instance = {
@@ -232,9 +208,23 @@ fn main() {
 
     let mut mouse_xy = Vector2i::new(0,0);
 
+
+
+
     let sprite = Sprite::new_with_color((0.,0.), (0.1,0.1), (1.,0.,0.,1.));
     let sprite2 = Sprite::new_with_color((-1.,-0.5), (0.1,0.1), (0.,1.,0.,1.));
 
+    /*
+        I need to get the image id from the CompuState
+        But the CompuState is owned by the vkprocessor I think...
+
+        I will also need to get the texture id
+    */
+
+    let compu_sprite1 = CompuSprite::new((-1.,-0.5), (0.1,0.1));
+
+
+
     while let Some(p) = window.get_position() {
 
         elapsed_time = timer.elap_time();
@@ -283,12 +273,6 @@ fn main() {
             return;
         }
 
-        /*
-
-
-
-
-        */
 
         let mut canvas = CanvasFrame::new();
         canvas.draw(&sprite);