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

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)