agb 0.23.1

Library for Game Boy Advance Development
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

use core::fmt::Write;

use crate::{
    display::{HEIGHT, WIDTH, bitmap3::Bitmap3, font::Font},
    fixnum::Vector2D,
};

static FONT: Font = include_font!("fnt/ark-pixel-10px-proportional-latin.ttf", 10);

pub struct BitmapTextRender<'bitmap, 'gba> {
    head_position: Vector2D<i32>,
    start_x: i32,
    bitmap: &'bitmap mut Bitmap3<'gba>,
    colour: u16,
    previous_char: Option<char>,
}

impl<'bitmap, 'gba> BitmapTextRender<'bitmap, 'gba> {
    pub fn new(
        bitmap: &'bitmap mut Bitmap3<'gba>,
        position: Vector2D<i32>,
        start_colour: u16,
    ) -> Self {
        Self {
            head_position: position,
            start_x: position.x,
            bitmap,
            colour: start_colour,
            previous_char: None,
        }
    }

    pub fn head_y_position(&self) -> i32 {
        self.head_position.y
    }

    fn render_letter(&mut self, c: char) {
        let letter = FONT.letter(c);

        self.head_position.x += letter.xmin as i32
            + self
                .previous_char
                .take()
                .map_or(0, |c| letter.kerning_amount(c));
        self.previous_char = Some(c);

        if self.head_position.x + letter.width as i32 >= WIDTH {
            self.newline();
        }

        if self.head_position.y + letter.height as i32 >= HEIGHT {
            return;
        }

        let y_position_start =
            self.head_position.y + FONT.ascent() - letter.height as i32 - letter.ymin as i32;

        for y in 0..letter.height as usize {
            for x in 0..letter.width as usize {
                let rendered = letter.bit_absolute(x, y);
                let x = x as i32 + self.head_position.x;
                let y = y as i32 + y_position_start;

                if rendered && (0..WIDTH).contains(&x) && (0..HEIGHT).contains(&y) {
                    self.bitmap.draw_point(x, y, self.colour);
                }
            }
        }

        self.head_position.x += letter.advance_width as i32;
    }

    fn render_char(&mut self, c: char) {
        match c {
            '\n' => {
                self.newline();
            }
            ' ' => {
                self.head_position.x += FONT.letter(' ').advance_width as i32;
            }
            letter => self.render_letter(letter),
        }
    }

    fn newline(&mut self) {
        self.head_position.x = self.start_x;
        self.head_position.y += FONT.line_height();
    }
}

impl Write for BitmapTextRender<'_, '_> {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        for c in s.chars() {
            self.render_char(c);
        }

        Ok(())
    }
}