gba_agb_font_renderer 0.3.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

pub const GLYPH_COUNT_FULL: usize = 256;
pub const HEADER_ALL: usize = 256 + 1 + 1 + 1 + 1;

/// 4bpp font for gba covering all 256 Latin-1 code points.
/// Font data location (ROM/IWRAM/EWRAM) is determined by the `full_font!` macro.
pub struct FullFont {
    pub char_widths: [u8; GLYPH_COUNT_FULL],
    pub data: &'static [u32],
    pub glyph_height: u32,
    pub glyph_size: usize,
    pub row_u32s: usize,
}

#[macro_export]
macro_rules! full_font {
    ($bytes:expr) => {{
        #[repr(C, align(4))]
        struct AlignedFont([u8; { $bytes.len() }]);
        static FONT_BYTES: AlignedFont = AlignedFont(*$bytes);
        $crate::font::full::FullFont::from_static_bytes(&FONT_BYTES.0)
    }};
    ($bytes:expr, iwram) => {{
        #[repr(C, align(4))]
        struct AlignedFont([u8; { $bytes.len() }]);
        #[unsafe(link_section = ".iwram")]
        static FONT_BYTES: AlignedFont = AlignedFont(*$bytes);
        $crate::font::full::FullFont::from_static_bytes(&FONT_BYTES.0)
    }};
    ($bytes:expr, ewram) => {{
        #[repr(C, align(4))]
        struct AlignedFont([u8; { $bytes.len() }]);
        #[unsafe(link_section = ".ewram")]
        static FONT_BYTES: AlignedFont = AlignedFont(*$bytes);
        $crate::font::full::FullFont::from_static_bytes(&FONT_BYTES.0)
    }};
}

impl FullFont {
    pub const fn from_static_bytes(bytes: &'static [u8]) -> Self {
        assert!(bytes.len() >= HEADER_ALL, "font bytes too short");
        let mode = bytes[0];
        assert!(mode == 1, "invalid font mode (must be 1 for full font)");

        let glyph_width = bytes[1];
        let glyph_height = bytes[2] as u32;
        let row_u32s = (glyph_width as usize + 7) >> 3;

        assert!(
            bytes.len() >= 3 + GLYPH_COUNT_FULL,
            "font bytes too short for full-256 mode"
        );
        let mut char_widths = [0u8; GLYPH_COUNT_FULL];
        let mut i = 0usize;
        while i < GLYPH_COUNT_FULL {
            char_widths[i] = bytes[3 + i];
            i += 1;
        }

        let data_len = bytes.len() - HEADER_ALL;
        assert!(
            data_len.is_multiple_of(4),
            "font pixel data length is not a multiple of 4"
        );
        let data: &'static [u32] = unsafe {
            core::slice::from_raw_parts(bytes.as_ptr().add(HEADER_ALL) as *const u32, data_len / 4)
        };

        let glyph_size = row_u32s * glyph_height as usize;
        Self {
            glyph_height,
            glyph_size,
            row_u32s,
            char_widths,
            data,
        }
    }
}