wgpu_glyph 0.28.0

A fast text renderer for wgpu, powered by glyph_brush
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use core::hash::BuildHasher;

use glyph_brush::DefaultSectionHasher;
use glyph_brush::ab_glyph::Font;
use glyph_brush::delegate_glyph_brush_builder_fns;

use super::GlyphBrush;

/// Builder for a [`GlyphBrush`](struct.GlyphBrush.html).
pub struct GlyphBrushBuilder<D, F, H = DefaultSectionHasher> {
    inner: glyph_brush::GlyphBrushBuilder<F, H>,
    texture_filter_method: wgpu::FilterMode,
    multisample_state: wgpu::MultisampleState,
    depth: D,
}

impl<F, H> From<glyph_brush::GlyphBrushBuilder<F, H>>
    for GlyphBrushBuilder<(), F, H>
{
    fn from(inner: glyph_brush::GlyphBrushBuilder<F, H>) -> Self {
        GlyphBrushBuilder {
            inner,
            texture_filter_method: wgpu::FilterMode::Linear,
            multisample_state: wgpu::MultisampleState::default(),
            depth: (),
        }
    }
}

impl GlyphBrushBuilder<(), ()> {
    /// Specifies the default font used to render glyphs.
    /// Referenced with `FontId(0)`, which is default.
    #[inline]
    pub fn using_font<F: Font>(font: F) -> GlyphBrushBuilder<(), F> {
        Self::using_fonts(vec![font])
    }

    pub fn using_fonts<F: Font>(fonts: Vec<F>) -> GlyphBrushBuilder<(), F> {
        GlyphBrushBuilder {
            inner: glyph_brush::GlyphBrushBuilder::using_fonts(fonts),
            texture_filter_method: wgpu::FilterMode::Linear,
            multisample_state: wgpu::MultisampleState::default(),
            depth: (),
        }
    }
}

impl<F: Font, D, H: BuildHasher> GlyphBrushBuilder<D, F, H> {
    delegate_glyph_brush_builder_fns!(inner);

    /// When multiple CPU cores are available spread rasterization work across
    /// all cores.
    ///
    /// Significantly reduces worst case latency in multicore environments.
    ///
    /// By default, this feature is __enabled__.
    ///
    /// # Platform-specific behaviour
    ///
    /// This option has no effect on wasm32.
    pub fn draw_cache_multithread(mut self, multithread: bool) -> Self {
        self.inner.draw_cache_builder =
            self.inner.draw_cache_builder.multithread(multithread);

        self
    }

    /// Sets the texture filtering method.
    pub fn texture_filter_method(
        mut self,
        filter_method: wgpu::FilterMode,
    ) -> Self {
        self.texture_filter_method = filter_method;
        self
    }

    /// Sets the multi-sampling state of the render pipeline.
    pub fn multisample_state(
        mut self,
        multisample_state: wgpu::MultisampleState,
    ) -> Self {
        self.multisample_state = multisample_state;
        self
    }

    /// Sets the section hasher. `GlyphBrush` cannot handle absolute section
    /// hash collisions so use a good hash algorithm.
    ///
    /// This hasher is used to distinguish sections, rather than for hashmap
    /// internal use.
    ///
    /// Defaults to [xxHash](https://docs.rs/twox-hash).
    pub fn section_hasher<T: BuildHasher>(
        self,
        section_hasher: T,
    ) -> GlyphBrushBuilder<D, F, T> {
        GlyphBrushBuilder {
            inner: self.inner.section_hasher(section_hasher),
            texture_filter_method: self.texture_filter_method,
            multisample_state: self.multisample_state,
            depth: self.depth,
        }
    }

    /// Sets the depth stencil.
    pub fn depth_stencil_state(
        self,
        depth_stencil_state: wgpu::DepthStencilState,
    ) -> GlyphBrushBuilder<wgpu::DepthStencilState, F, H> {
        GlyphBrushBuilder {
            inner: self.inner,
            texture_filter_method: self.texture_filter_method,
            multisample_state: self.multisample_state,
            depth: depth_stencil_state,
        }
    }
}

impl<F: Font + Sync, H: BuildHasher> GlyphBrushBuilder<(), F, H> {
    /// Builds a `GlyphBrush` using the given `wgpu::Device` that can render
    /// text for texture views with the given `render_format`.
    pub fn build(
        self,
        device: &wgpu::Device,
        render_format: wgpu::TextureFormat,
    ) -> GlyphBrush<(), F, H> {
        GlyphBrush::<(), F, H>::new(
            device,
            self.texture_filter_method,
            self.multisample_state,
            render_format,
            self.inner,
        )
    }
}

impl<F: Font + Sync, H: BuildHasher>
    GlyphBrushBuilder<wgpu::DepthStencilState, F, H>
{
    /// Builds a `GlyphBrush` using the given `wgpu::Device` that can render
    /// text for texture views with the given `render_format`.
    pub fn build(
        self,
        device: &wgpu::Device,
        render_format: wgpu::TextureFormat,
    ) -> GlyphBrush<wgpu::DepthStencilState, F, H> {
        GlyphBrush::<wgpu::DepthStencilState, F, H>::new(
            device,
            self.texture_filter_method,
            self.multisample_state,
            render_format,
            self.depth,
            self.inner,
        )
    }
}