rafx-plugins 0.0.16

Rendering framework built on an extensible asset pipeline
Documentation 
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

use super::{TextDrawCommand, TextDrawData};
use crate::assets::font::FontAsset;
use fnv::FnvHashMap;
use hydrate_base::handle::{ArtifactHandle, Handle};
use hydrate_base::LoadHandle;

pub struct AppendText<'a>(&'a mut TextResource, glam::Vec3);

impl<'a> AppendText<'a> {
    pub fn append(
        self,
        text: String,
        font: &Handle<FontAsset>,
        size: f32,
        color: glam::Vec4,
    ) -> AppendText<'a> {
        self.0.do_add_text(text, self.1, font, size, color, true)
    }
}

pub struct TextResource {
    fonts: FnvHashMap<LoadHandle, Handle<FontAsset>>,
    text_draw_commands: Vec<TextDrawCommand>,
}

impl TextResource {
    pub fn new() -> Self {
        TextResource {
            fonts: Default::default(),
            text_draw_commands: Default::default(),
        }
    }

    pub fn add_text(
        &mut self,
        text: String,
        position: glam::Vec3,
        font: &Handle<FontAsset>,
        size: f32,
        color: glam::Vec4,
    ) -> AppendText {
        self.do_add_text(text, position, font, size, color, false)
    }

    pub(super) fn do_add_text(
        &mut self,
        text: String,
        position: glam::Vec3,
        font: &Handle<FontAsset>,
        size: f32,
        color: glam::Vec4,
        is_append: bool,
    ) -> AppendText {
        let font = self.fonts.entry(font.load_handle()).or_insert(font.clone());

        self.text_draw_commands.push(TextDrawCommand {
            text,
            position,
            font: font.load_handle(),
            size,
            color,
            is_append,
        });

        AppendText(self, position)
    }

    // Returns the draw data, leaving this object in an empty state
    pub(super) fn take_text_draw_data(&mut self) -> TextDrawData {
        TextDrawData {
            fonts: std::mem::take(&mut self.fonts),
            text_draw_commands: std::mem::take(&mut self.text_draw_commands),
        }
    }

    // Recommended to call every frame to ensure that this doesn't grow unbounded
    pub fn clear(&mut self) {
        self.take_text_draw_data();
    }
}