1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

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

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