this is a week or so worth of brainstorming. Looking at pulling everything sprite related into it's own little struct. And also doing a message everything arch

src/canvas/canvas_frame.rs

@@ -6,30 +6,34 @@ use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
 use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, Handle};
 use vulkano::pipeline::vertex::Vertex;
 use std::any::Any;
-use crate::{VertexTypeContainer, Move, Geom};
+use crate::{VertexTypeContainer};
 use winit::event::Event;
-use crate::util::tr_event::TrEvent;
+use crate::util::tr_event::{TrEvent, TrUIEvent};
+use crate::drawables::sprite::{Velocity, Geometry};
 
 /// Trait which may be inherited by objects that wish to be drawn to the screen
 pub trait Drawable {
-    fn get(&self,
-           window_size: (u32, u32),
-           position: (f32, f32),
-           rotation: f32,
-           size: (f32, f32),
-           depth: f32,
+
+    // Render expects the implementer to create custom render logic based on interior data within
+    // the struct. This data as of right now, will *only* be mutatable via events & update
+    fn render(&self,
+              window_size: (u32, u32),
+              position: (f32, f32),
+              rotation: f32,
+              size: (f32, f32),
+              depth: f32,
     ) -> Vec<VertexTypeContainer>;
+
+    // Update simply passes the delta time. The implementor doesn't necessarily need to use delta_time
+    // or even add anything other than a Vec::new() to the function.
+    fn update<T>(&self, delta_time: f32) -> Vec<TrUIEvent<T>>;
+
+    // Notify is where custom events created in other parts of the system will be ingested. It
+    // might be a good idea in the future to have some of pre-function-call filtering so we
+    // don't have as many notifies that just immediately reject.
+    fn notify<Y, T>(&self, tr_event : Vec<TrEvent<Y>>, ui_events: Vec<TrUIEvent<T>>) -> Vec<TrUIEvent<T>>;
 }
 
-/// Trait which may be inherited by objects that wish to receive events
-pub trait Eventable<T> {
-    fn notify(&mut self, event: &TrEvent<T>) -> ();
-}
-
-/// Trait which may be inherited by objects that wish to be updated
-pub trait Updatable {
-    fn update(&mut self, delta_time: f32) -> ();
-}
 
 /// Accumulator for Vectors of VertexTypes
 #[derive(Default)]
@@ -54,8 +58,8 @@ impl CanvasFrame {
     }
 
     /// Push this drawable onto the back of the accumulator
-    pub fn draw(&mut self, drawable: &dyn Drawable, mv: Move, geom: Geom) {
-        for i in drawable.get(
+    pub fn draw(&mut self, drawable: &dyn Drawable, mv: Velocity, geom: Geometry) {
+        for i in drawable.render(
             self.window_size,
             (mv.pos_x, mv.pos_y),
             geom.rotation,