ux-dx 0.2.1

3D Graphics Primitives for Angular Rust
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
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
141
142

use glyph_brush::ab_glyph;
use iced_graphics::font;
use std::{cell::RefCell, collections::HashMap};

use crate::support::glyph;

use super::Transformation;

#[derive(Debug)]
pub struct Pipeline {
    draw_brush: RefCell<glyph::GlyphBrush>,
    draw_font_map: RefCell<HashMap<String, glyph_brush::FontId>>,
    measure_brush: RefCell<glyph_brush::GlyphBrush<()>>,
}

impl Pipeline {
    pub fn new(default_font: Option<&[u8]>) -> Self {
        let default_font = default_font.map(|slice| slice.to_vec());

        // TODO: Font customization
        #[cfg(feature = "default_system_font")]
        let default_font = {
            default_font.or_else(|| {
                font::Source::new()
                    .load(&[font::Family::SansSerif, font::Family::Serif])
                    .ok()
            })
        };

        let default_font = default_font.unwrap_or_else(|| font::FALLBACK.to_vec());

        let font = ab_glyph::FontArc::try_from_vec(default_font).unwrap_or_else(|_| {
            log::warn!(
                "System font failed to load. Falling back to \
                    embedded font..."
            );

            ab_glyph::FontArc::try_from_slice(font::FALLBACK).expect("Load fallback font")
        });

        let draw_brush = glyph::GlyphBrushBuilder::using_font(font.clone())
            .initial_cache_size((2048, 2048))
            .draw_cache_multithread(false) // TODO: Expose as a configuration flag
            .build();

        let measure_brush = glyph_brush::GlyphBrushBuilder::using_font(font).build();

        Pipeline {
            draw_brush: RefCell::new(draw_brush),
            draw_font_map: RefCell::new(HashMap::new()),
            measure_brush: RefCell::new(measure_brush),
        }
    }

    pub fn queue(&mut self, section: glyph_brush::Section<'_>) {
        self.draw_brush.borrow_mut().queue(section);
    }

    pub fn draw_queued(&mut self, transformation: Transformation, region: glyph::Region) {
        self.draw_brush
            .borrow_mut()
            .draw_queued_with_transform_and_scissoring(transformation.into(), region)
            .expect("Draw text");
    }

    pub fn measure(
        &self,
        content: &str,
        size: f32,
        font: iced_native::Font,
        bounds: iced_native::Size,
    ) -> (f32, f32) {
        use glyph_brush::GlyphCruncher;

        let glyph::FontId(font_id) = self.find_font(font);

        let section = glyph_brush::Section {
            bounds: (bounds.width, bounds.height),
            text: vec![glyph_brush::Text {
                text: content,
                scale: size.into(),
                font_id: glyph::FontId(font_id),
                extra: glyph_brush::Extra::default(),
            }],
            ..Default::default()
        };

        if let Some(bounds) = self.measure_brush.borrow_mut().glyph_bounds(section) {
            (bounds.width().ceil(), bounds.height().ceil())
        } else {
            (0.0, 0.0)
        }
    }

    pub fn trim_measurement_cache(&mut self) {
        // TODO: We should probably use a `GlyphCalculator` for this. However,
        // it uses a lifetimed `GlyphCalculatorGuard` with side-effects on drop.
        // This makes stuff quite inconvenient. A manual method for trimming the
        // cache would make our lives easier.
        loop {
            let action = self
                .measure_brush
                .borrow_mut()
                .process_queued(|_, _| {}, |_| {});

            match action {
                Ok(_) => break,
                Err(glyph_brush::BrushError::TextureTooSmall { suggested }) => {
                    let (width, height) = suggested;

                    self.measure_brush
                        .borrow_mut()
                        .resize_texture(width, height);
                }
            }
        }
    }

    pub fn find_font(&self, font: iced_native::Font) -> glyph::FontId {
        match font {
            iced_native::Font::Default => glyph::FontId(0),
            iced_native::Font::External { name, bytes } => {
                if let Some(font_id) = self.draw_font_map.borrow().get(name) {
                    return *font_id;
                }

                let font = ab_glyph::FontArc::try_from_slice(bytes).expect("Load font");

                let _ = self.measure_brush.borrow_mut().add_font(font.clone());

                let font_id = self.draw_brush.borrow_mut().add_font(font);

                let _ = self
                    .draw_font_map
                    .borrow_mut()
                    .insert(String::from(name), font_id);

                font_id
            }
        }
    }
}