gba_agb_font_renderer 0.2.0

Bitmap font renderer for GBA/AGB
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

use crate::prelude::{FullFont, PrintableFont};

pub mod full;
pub mod printable;

/// 4bpp font for gba
pub trait AgbFont {
    fn char_widths(&self) -> &[u8];

    #[inline]
    fn char_width(&self, c: u8) -> u8 {
        self.char_widths()[c as usize - self.char_offset()]
    }

    fn char_offset(&self) -> usize;

    fn data(&self) -> &[u32];

    fn glyph_height(&self) -> u32;

    fn glyph_size(&self) -> usize;

    fn row_u32s(&self) -> usize;

    /// Return the pixel data for the glyph corresponding to `c`.
    ///
    /// Panics in debug builds if `c` is outside the font's character range.
    /// In release builds, out-of-range values produce undefined pixel data.
    fn glyph(&self, c: u8) -> &[u32] {
        if cfg!(debug_assertions) && self.char_offset() != 0 && !(32..=126).contains(&c) {
            panic!("glyph {c} out of printable bounds");
        }
        let idx = c as usize - self.char_offset();
        let offset = idx * self.glyph_size();
        unsafe {
            self.data()
                .get_unchecked(offset..offset + self.glyph_size())
        }
    }

    /// Size of text in pixels if rendered with this font.
    fn size_of(&self, text: &[u8], wrap_at: u8) -> (u8, u8) {
        let max_width = wrap_at as u32;
        if text.is_empty() {
            return (0, 0);
        }

        let mut max_encountered_width: u32 = 0;
        let mut current_line_width: u32 = 0;
        let mut total_height: u32 = self.glyph_height();

        for &c in text {
            if c == b'\n' {
                if current_line_width > max_encountered_width {
                    max_encountered_width = current_line_width;
                }
                current_line_width = 0;
                total_height += self.glyph_height();
            } else {
                let char_w = self.char_width(c) as u32;
                if current_line_width + char_w > max_width {
                    if current_line_width > max_encountered_width {
                        max_encountered_width = current_line_width;
                    }
                    current_line_width = char_w;
                    total_height += self.glyph_height();
                } else {
                    current_line_width += char_w;
                }
            }
        }

        if current_line_width > max_encountered_width {
            max_encountered_width = current_line_width;
        }

        (max_encountered_width as u8, total_height as u8)
    }
}

macro_rules! impl_agb_font {
    ($font_class:ident, $offset: expr) => {
        impl AgbFont for $font_class {
            #[inline]
            fn char_widths(&self) -> &[u8] {
                &self.char_widths
            }

            #[inline]
            fn char_offset(&self) -> usize {
                $offset
            }

            #[inline]
            fn data(&self) -> &[u32] {
                &self.data
            }

            #[inline]
            fn glyph_height(&self) -> u32 {
                self.glyph_height
            }

            #[inline]
            fn glyph_size(&self) -> usize {
                self.glyph_size
            }

            #[inline]
            fn row_u32s(&self) -> usize {
                self.row_u32s
            }
        }
    };
}

impl_agb_font!(PrintableFont, 32);
impl_agb_font!(FullFont, 0);