going to abstract the events like I did for the vkcaster

src/canvas/canvas_frame.rs

@@ -7,7 +7,7 @@ use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, Ca
 use vulkano::pipeline::vertex::Vertex;
 use std::any::Any;
 use crate::VertexTypes;
-use vulkano::sync::Event;
+use winit::event::Event;
 
 /// Trait which may be inherited by objects that wish to be drawn to the screen
 pub trait Drawable {
@@ -15,8 +15,8 @@ pub trait Drawable {
 }
 
 /// Trait which may be inherited by objects that wish to receive events
-pub trait Eventable {
+pub trait Eventable<T> {
-    fn notify(&self, event: &Event) -> ();
+    fn notify(&mut self, event: &Event<T>) -> ();
 }
 
 /// Accumulator for Vectors of VertexTypes

src/drawables/sprite.rs

@@ -3,78 +3,89 @@ use crate::canvas::*;
 use crate::canvas::managed::handles::{CanvasFontHandle, CanvasImageHandle, CanvasTextureHandle, Handle};
 use crate::canvas::canvas_frame::{Drawable, Eventable};
 use crate::util::vertex::{VertexTypes, TextureVertex3D, Vertex3D};
-use winit::event::{DeviceEvent, MouseButton, ElementState, Event};
+use winit::event::{DeviceEvent, MouseButton, ElementState, Event, WindowEvent};
 
 ///
 #[derive(Debug, Clone)]
 pub struct Sprite {
-    pub verts: VertexTypes,
+    verts: VertexTypes,
 
     position: (f32, f32),
     size: (f32, f32),
+    depth: f32,
+    texture_handle: Arc<CanvasTextureHandle>,
 }
 
 /// Container class which implements drawable.
 impl Sprite {
-    ///
-    pub fn new(position: (f32, f32),
-               size: (f32, f32),
-               depth: u32,
-               texture_handle: Arc<CanvasTextureHandle>) -> Sprite {
-        let normalized_depth = (depth as f32 / 255.0);
 
-        let verts = vec![
+
+    fn generate_verts(position: (f32, f32), size: (f32, f32), depth: f32,) -> Vec<TextureVertex3D> {
+        vec![
             TextureVertex3D {
-                v_position: [position.0, position.1, normalized_depth],                   // top left
+                v_position: [position.0, position.1, depth],                   // top left
                 ti_position: [-0.0, -0.0],
             },
             TextureVertex3D {
-                v_position: [position.0, position.1 + size.1, normalized_depth],          // bottom left
+                v_position: [position.0, position.1 + size.1, depth],          // bottom left
                 ti_position: [-0.0, 1.0],
             },
             TextureVertex3D {
-                v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
+                v_position: [position.0 + size.0, position.1 + size.1, depth], // bottom right
                 ti_position: [1.0, 1.0],
             },
             TextureVertex3D {
-                v_position: [position.0, position.1, normalized_depth],                   // top left
+                v_position: [position.0, position.1, depth],                   // top left
                 ti_position: [-0.0, -0.0],
             },
             TextureVertex3D {
-                v_position: [position.0 + size.0, position.1 + size.1, normalized_depth], // bottom right
+                v_position: [position.0 + size.0, position.1 + size.1, depth], // bottom right
                 ti_position: [1.0, 1.0],
             },
             TextureVertex3D {
-                v_position: [position.0 + size.0, position.1, normalized_depth],          // top right
+                v_position: [position.0 + size.0, position.1, depth],          // top right
                 ti_position: [1.0, -0.0],
             },
-        ];
+        ]
+    }
+
+    ///
+    pub fn new(position: (f32, f32),
+               size: (f32, f32),
+               depth: u32,
+               texture_handle: Arc<CanvasTextureHandle>) -> Sprite {
+
+        let normalized_depth = (depth as f32 / 255.0);
 
         Sprite {
-            verts: VertexTypes::TextureType(verts, texture_handle),
+            verts: VertexTypes::TextureType(Sprite::generate_verts(position, size, normalized_depth), texture_handle.clone()),
             position: position,
             size: size,
+            depth: normalized_depth,
+            texture_handle: texture_handle.clone(),
         }
     }
 }
 
 impl Drawable for Sprite {
     fn get(&self) -> VertexTypes {
-        self.verts.clone()
+        VertexTypes::TextureType(Sprite::generate_verts(self.position, self.size, self.depth), self.texture_handle.clone())
     }
 }
 
-impl Eventable<T> for Sprite {
+impl<T> Eventable<T> for Sprite {
-    fn notify<T>(&self, event: &Event<T>) -> () {
+    fn notify(&mut self, event: &Event<T>) -> () {
         match event {
-            Event::DeviceEvent { event: DeviceEvent::Button{button, state }, .. } => {
+            Event::WindowEvent { event: WindowEvent::MouseInput{ device_id, state, button, modifiers }, .. } => {
-                match button.id.unwrap() {
+                match button {
                     MouseButton::Left => {
-                        if state.state == ElementState::Pressed {
+                        if *state == ElementState::Pressed {
-                            // processor.save_edges_image();
+                            self.position = (self.position.0, self.position.1 + 0.1);
                         }
                     },
-                    _ => ()
+                    _ => {
+
+                    }
                 }
             }
             _ => {}

src/main.rs

@@ -23,7 +23,7 @@ use winit::event_loop::{EventLoop, ControlFlow};
 use winit::platform::unix::WindowBuilderExtUnix;
 use winit::window::WindowBuilder;
 
-use crate::canvas::canvas_frame::{CanvasFrame, Drawable};
+use crate::canvas::canvas_frame::{CanvasFrame, Drawable, Eventable};
 use crate::canvas::managed::handles::{CanvasFontHandle, CanvasTextureHandle, Handle};
 use crate::compute::compu_frame::CompuFrame;
 use crate::compute::managed::handles::{CompuBufferHandle, CompuKernelHandle};
@@ -114,7 +114,7 @@ pub fn main() {
     //let font_handle : Arc<CanvasFontHandle> =
     //    processor.get_font_handle(String::from("sansation.ttf")).unwrap();
 
-    let funky_sprite = Sprite::new((0.0, 0.5), (0.5, 0.5), 0, funky_handle.clone());
+    let mut funky_sprite = Sprite::new((0.0, 0.5), (0.5, 0.5), 0, funky_handle.clone());
     let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
     let rect = Rect::new((-0.5, -0.5), (0.5, 0.5), 1);
 
@@ -200,11 +200,14 @@ pub fn main() {
                     _ => ()
                 }
             }
-//                Event::DeviceEvent { event: DeviceEvent::Button(mouse_input), .. } => {
-//                    mouse_xy.x
-//                },
             _ => ()
         }
+
+        match event {
+            _ => {
+                funky_sprite.notify(&event);
+            }
+        }
     });
 
     drop(l);