Trac3r-rust/src/canvas/canvas_frame.rs

use crate::util::vertex_3d::{Vertex3D};
use std::sync::Arc;
use std::collections::HashMap;
use crate::canvas::canvas_state::{Drawable};
use std::hash::Hash;
use crate::canvas::*;
use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle};
use crate::canvas::managed::shader::text_shader::GlyphInstance;

/// I dont know why this isnt working
/// fqowiejf
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>>
}


/*
This is sort of the beginning of our interface with the user definable sprites.
Will be taking in multiple type of items

TEXT
    FontHandle
    VertexDefintion
        color
        position
        instances (string)
Textured
    TextureHandle
    VertexDefintion
        position
        coords
        size

Vertex definition is directly correlated to the compiled code. How do I bucket these

I guess I could store them and set handles like I do textures

The only ent that can create these vertex handles is the vkprocessor.
    So Text can only get a vertex definition by going like shader.get_definition()


Text
    FontHandle
    VertexHandle


Drawable must include
    shader_handle (but how to I get this to the text? this is runtime)

Okay, no. Maybe a default shader type of setup. With a shader handle override????

Type: Text
      Textured
      Img
      Color

frame.draw(text) {

    text.type == TEXT { // When it matches to default text shader
        text_shader.get_definition()
        text_shader.get_pipeline()
    }
    ...
    else { // When the user passes in a shader
        text.shader_handle.get_definition()
        text.shader_handle.get_pipeline()
    }
}

// Has default shader
let text = Text::new("asdoif");

let frame = CanvasFrame::new();
frame.draw(text);

vkprocessor.run(frame);

*/

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());
                    }
                }
            }
        }
    }
}

pub struct GenericCanvasFrame<H, V, In> {
    frame_data: HashMap<H, Vec<(Vec<V>, Vec<In>)>>
}
//
//impl<V, In> GenericCanvasFrame<Vertex3D, V, In>  {
//
//    /// Creates a bare canvas frame with empty accumulators
//    pub fn new() -> GenericCanvasFrame<Vertex3D, V, In> {
//        GenericCanvasFrame {
//            frame_data: Default::default()
//        }
//    }
//
//    pub fn draw(&mut self, drawable: &dyn DrawableTest<V, Vertex3D, In>) {
//        self.frame_data
//            .entry(drawable.get_handle().clone())
//            .or_insert(Vec::new())
//            .push((drawable.get_vertices(), drawable.get_instances()));
//    }
//}