bringing docs up to date

src/canvas/canvas_frame.rs

@@ -7,153 +7,23 @@ use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, Ca
 use crate::canvas::managed::shader::text_shader::GlyphInstance;
 use vulkano::pipeline::vertex::Vertex;
 use std::any::Any;
-
-
-
-
-pub mod dynhash {
-    use std::any::Any;
-    use std::hash::{Hash, Hasher};
-
-    pub trait DynEq: Any {
-        fn dyn_eq(&self, other: &dyn DynEq) -> bool;
-
-        fn as_any(&self) -> &dyn Any;
-    }
-
-    pub trait DynHash: DynEq {
-        fn dyn_hash(&self, hasher: &mut dyn Hasher);
-
-        fn as_dyn_eq(&self) -> &dyn DynEq;
-    }
-
-    impl<H: Eq + Any> DynEq for H {
-        fn dyn_eq(&self, other: &dyn DynEq) -> bool {
-            if let Some(other) = other.as_any().downcast_ref::<H>() {
-                self == other
-            } else {
-                false
-            }
-        }
-
-        fn as_any(&self) -> &dyn Any {
-            self
-        }
-    }
-
-    impl<H: Hash + DynEq> DynHash for H {
-        fn dyn_hash(&self, mut hasher: &mut dyn Hasher) {
-            H::hash(self, &mut hasher)
-        }
-
-        fn as_dyn_eq(&self) -> &dyn DynEq {
-            self
-        }
-    }
-
-    impl PartialEq for dyn DynHash {
-        fn eq(&self, other: &dyn DynHash) -> bool {
-            self.dyn_eq(other.as_dyn_eq())
-        }
-    }
-
-    impl Eq for dyn DynHash {}
-
-    impl Hash for dyn DynHash {
-        fn hash<H: Hasher>(&self, hasher: &mut H) {
-            self.dyn_hash(hasher)
-        }
-    }
-}
-use crate::canvas::canvas_frame::dynhash::DynHash;
 use crate::VertexTypes;
 
-
-
-pub trait DrawableTest {
+/// Trait which may be inherited by objects that wish to be drawn to the screen
+pub trait Drawable {
     fn get(&self) -> VertexTypes;
 }
 
+/// Accumulator for Vectors of VertexTypes
 #[derive(Default)]
-pub struct CanvasFrameTest {
+pub struct CanvasFrame {
     pub map: Vec<VertexTypes>,
 }
 
-impl CanvasFrameTest {
-    pub fn draw(&mut self, drawable: &dyn DrawableTest) {
+impl CanvasFrame {
+
+    /// Push this drawable onto the back of the accumulator
+    pub fn draw(&mut self, drawable: &dyn Drawable) {
         self.map.push(drawable.get());
     }
 }
-
-pub trait Drawable {
-    fn get_vertices(&self) -> Vec<(f32, f32, f32)>;
-    fn get_color(&self) -> (f32, f32, f32, f32);
-    fn get_ti_coords(&self) -> Vec<(f32, f32)>;
-
-    fn get_texture_handle(&self) -> Option<Arc<CanvasTextureHandle>>;
-    fn get_image_handle(&self) -> Option<Arc<CanvasImageHandle>>;
-// fn get_text_handle(&self) -> Option<Arc<CanvasTextHandle>>;
-
-    // These needs to return a vector of raw-ass data in addition to the definition for this data
-    fn collect(&self) -> Vec<RuntimeVertexDef> {
-        let color = self.get_color();
-//        self.get_vertices().iter().zip(self.get_ti_coords().iter()).map(|(a, b)|
-//            Vertex3D {
-//                v_position: [a.0, a.1, a.2],
-//                color: [color.0, color.1, color.2, color.3],
-//                ti_position: [b.0, b.1],
-//            }).collect()
-// TODO
-        vec![RuntimeVertexDef::from_primitive(0)]
-    }
-}
-
-
-pub trait VertexDefinitionAndData {}
-
-
-pub struct CanvasFrame {
-    pub colored_drawables: Vec<RuntimeVertexDef>,
-    pub textured_drawables: HashMap<Arc<CanvasTextureHandle>, Vec<Vec<RuntimeVertexDef>>>,
-    pub image_drawables: HashMap<Arc<CanvasImageHandle>, Vec<Vec<RuntimeVertexDef>>>,
-    pub text_drawables: HashMap<Arc<CanvasFontHandle>, Vec<GlyphInstance>>,
-}
-
-impl CanvasFrame {
-    /// Creates a bare canvas frame with empty accumulators a
-    pub fn new() -> CanvasFrame {
-        CanvasFrame {
-            colored_drawables: vec![],
-            textured_drawables: Default::default(),
-            image_drawables: Default::default(),
-            text_drawables: Default::default(),
-        }
-    }
-
-
-    // TODO: Fix this for text and fonts
-    /// Accumulates the drawables collected Vertex2D's
-    pub fn draw(&mut self, drawable: &dyn Drawable) {
-        match drawable.get_texture_handle() {
-            Some(handle) => {
-                self.textured_drawables
-                    .entry(handle.clone())
-                    .or_insert(Vec::new())
-                    .push(drawable.collect());
-            }
-            None => {
-                match drawable.get_image_handle() {
-                    Some(handle) => {
-                        self.image_drawables
-                            .entry(handle.clone())
-                            .or_insert(Vec::new())
-                            .push(drawable.collect());
-                    }
-                    None => {
-                        self.colored_drawables.extend(drawable.collect());
-                    }
-                }
-            }
-        }
-    }
-}