compute is back in. Crashing the nvidia driver on buffer operations in the kernel....

resources/shaders/simple-edge.compute

@@ -60,7 +60,7 @@ void main() {
     else {
         //p.w = 125;
     }
-
+    //write_buffer.buf[0] = write_buffer.buf[0];
     write_buffer.buf[idx] = (write_buffer.buf[idx] & (~0x000000FF) ) | (p.x);
     write_buffer.buf[idx] = (write_buffer.buf[idx] & (~0x0000FF00) ) | (p.y << 8);
     write_buffer.buf[idx] = (write_buffer.buf[idx] & (~0x00FF0000) ) | (p.z << 16);

src/compute/compu_frame.rs

@@ -1,7 +1,9 @@
 use std::sync::Arc;
 use crate::canvas::managed::handles::{CanvasImageHandle};
 use crate::compute::managed::handles::{CompuKernelHandle, CompuBufferHandle};
-use crate::compute::managed::compu_sprite::CompuSprite;
+use crate::drawables::compu_sprite::CompuSprite;
+use crate::canvas::canvas_frame::Drawable;
+use crate::util::vertex::VertexTypes;
 
 pub struct CompuFrame {
     // Vec<(Buffer, Kernel)>
@@ -51,6 +53,10 @@ impl CompuFrame {
                                buffer: Arc<CompuBufferHandle>,
                                kernel: Arc<CompuKernelHandle>,
                                sprite: &CompuSprite) {
-     //   self.swapped_to_image.push((buffer, sprite.get_image_handle().unwrap().clone(), kernel))
+
+        if let VertexTypes::ImageType(a, b) = sprite.get() {
+            self.swapped_to_image.push((buffer, b, kernel))
+        }
+
     }
 }

src/compute/managed/compu_buffer.rs

@@ -40,7 +40,7 @@ impl CompuBuffers {
         };
 
         // Settings buffer which holds i32's
-        // Compile macros into the kernel eventually to index them
+        // TODO: Compile macros into the kernel eventually to index them
         let settings_buffer = {
             let vec = vec![dimensions.0, dimensions.1];
             let mut buff = vec.iter();

src/compute/managed/compu_sprite.rs

@@ -1,49 +0,0 @@
-use std::sync::Arc;
-use crate::canvas::managed::handles::{CanvasImageHandle, CanvasTextureHandle};
-
-pub struct CompuSprite {
-    pub vertices: [(f32, f32, f32); 6],
-    pub ti_position: [(f32, f32); 6],
-
-    position: (f32, f32),
-    size: (f32, f32),
-    color: (f32, f32, f32, f32),
-    image_handle: Arc<CanvasImageHandle>,
-
-}
-
-impl CompuSprite {
-    pub fn new(position: (f32, f32),
-               size: (f32, f32),
-               depth: u32,
-               image_size: (f32, f32),
-               image_handle: Arc<CanvasImageHandle>) -> CompuSprite {
-
-        let normalized_depth = (depth as f32 / 255.0);
-
-        CompuSprite {
-            vertices: [
-                (position.0, position.1                  , normalized_depth),    // top left
-                (position.0, position.1 + size.1         , normalized_depth),    // bottom left
-                (position.0 + size.0, position.1 + size.1, normalized_depth),    // bottom right
-                (position.0, position.1                  , normalized_depth),    // top left
-                (position.0 + size.0, position.1 + size.1, normalized_depth),    // bottom right
-                (position.0 + size.0, position.1         , normalized_depth),    // top right
-            ],
-
-            ti_position: [
-                (0.0         ,  0.0         ),          // top left
-                (0.0         ,  image_size.1),          // bottom left
-                (image_size.0,  image_size.1),          // bottom right
-                (0.0         ,  0.0         ),          // top left
-                (image_size.0,  image_size.1),          // bottom right
-                (image_size.0,  0.0         ),          // top right
-            ],
-            position: position,
-            size: size,
-            color: (0.0, 0.0, 0.0, 0.0),
-            image_handle: image_handle.clone(),
-        }
-    }
-}
-

src/compute/managed/mod.rs

@@ -1,5 +1,4 @@
 
 pub mod compu_buffer;
-pub mod compu_sprite;
 pub mod compu_kernel;
 pub mod handles;

src/drawables/compu_sprite.rs

@@ -0,0 +1,59 @@
+use std::sync::Arc;
+use crate::canvas::managed::handles::{CanvasImageHandle, CanvasTextureHandle};
+use crate::canvas::canvas_frame::Drawable;
+use crate::util::vertex::{VertexTypes, ImageVertex3D};
+
+pub struct CompuSprite {
+
+    pub verts: VertexTypes,
+
+    position: (f32, f32),
+    size: (f32, f32),
+    color: (f32, f32, f32, f32),
+
+}
+
+impl CompuSprite {
+    pub fn new(position: (f32, f32),
+               size: (f32, f32),
+               depth: u32,
+               image_size: (f32, f32),
+               image_handle: Arc<CanvasImageHandle>) -> CompuSprite {
+
+        let normalized_depth = (depth as f32 / 255.0);
+
+        let verts = vec![
+            ImageVertex3D {
+                v_position: [position.0, position.1, normalized_depth],                   // top left
+                ti_position: [-0.0, -0.0] },
+            ImageVertex3D {
+                v_position: [position.0, position.1 + size.1, normalized_depth],          // bottom left
+                ti_position: [-0.0, image_size.1] },
+            ImageVertex3D {
+                v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
+                ti_position: [image_size.0, image_size.1] },
+            ImageVertex3D {
+                v_position: [position.0, position.1, normalized_depth],                   // top left
+                ti_position: [-0.0, -0.0] },
+            ImageVertex3D {
+                v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
+                ti_position: [image_size.0, image_size.1] },
+            ImageVertex3D {
+                v_position: [position.0 + size.0, position.1, normalized_depth],          // top right
+                ti_position: [image_size.0, -0.0] },
+        ];
+
+        CompuSprite {
+            verts: VertexTypes::ImageType(verts, image_handle.clone()),
+            position: position,
+            size: size,
+            color: (0.0, 0.0, 0.0, 0.0),
+        }
+    }
+}
+
+impl Drawable for CompuSprite {
+    fn get(&self) -> VertexTypes {
+        self.verts.clone()
+    }
+}

src/drawables/mod.rs

@@ -1,3 +1,4 @@
 pub mod polygon;
 pub mod sprite;
 pub mod rect;
+pub mod compu_sprite;

src/main.rs

@@ -24,13 +24,13 @@ use crate::util::load_raw;
 use vulkano::instance::debug::DebugCallback;
 use crate::compute::compu_frame::CompuFrame;
 use crate::canvas::canvas_frame::{CanvasFrame, Drawable};
-use crate::compute::managed::compu_sprite::CompuSprite;
 use std::sync::Arc;
 use crate::canvas::managed::handles::{CanvasTextureHandle, Handle, CanvasFontHandle};
 use crate::util::vertex::{VertexTypes, TextureVertex3D};
 use crate::compute::managed::handles::{CompuBufferHandle, CompuKernelHandle};
 use crate::drawables::sprite::Sprite;
 use crate::drawables::rect::Rect;
+use crate::drawables::compu_sprite::CompuSprite;
 
 pub mod util;
 pub mod vkprocessor;
@@ -172,13 +172,13 @@ pub fn main() {
         }
 
         let mut canvas_frame = CanvasFrame::default();
-//        canvas_frame.draw(&funky_sprite);
+        canvas_frame.draw(&funky_sprite);
-//        canvas_frame.draw(&sfml_sprite);
+        canvas_frame.draw(&compu_sprite1);
 //        canvas_frame.draw(&rect);
 
         let mut compu_frame = CompuFrame::new();
-        compu_frame.add(compute_buffer.clone(), compute_kernel.clone());
+        //compu_frame.add(compute_buffer.clone(), compute_kernel.clone());
-//        compu_frame.add_with_image_swap(compute_buffer.clone(), compute_kernel.clone(), &compu_sprite1);
+        compu_frame.add_with_image_swap(compute_buffer.clone(), compute_kernel.clone(), &compu_sprite1);
 
 
         {