devela 0.28.0

A development substrate of coherence.
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

// devela::media::bitmap::tests

use super::*;

const GLYPHS: [u8; 2] = [
    0b_0001, // A
    0b_0010, // B
];
const EXTRAS: [(char, u8); 2] = [
    ('Ω', 0b_0100),
    ('A', 0b_1111), // must not override the sequential glyph
];

const FONT: FontBitmap<u8> =
    FontBitmap::new(&GLYPHS, 'A', 2, 2, 1, 3, 3).with_extra_glyphs(&EXTRAS);

#[test]
fn lookup() {
    assert_eq!(FONT.glyph('A'), Some(0b_0001));
    assert_eq!(FONT.glyph('B'), Some(0b_0010));
    assert_eq!(FONT.glyph('Ω'), Some(0b_0100));
    assert_eq!(FONT.glyph('C'), None);

    assert!(FONT.has_glyph('Ω'));
    assert!(!FONT.has_glyph('X'));
    assert_eq!(FONT.glyph_or('X', 0b_1000), 0b_1000);
}

#[test]
fn metrics() {
    assert_eq!(FONT.text_advance(""), 0);
    assert_eq!(FONT.text_width(""), 0);

    assert_eq!(FONT.text_advance("A"), 3);
    assert_eq!(FONT.text_width("A"), 2);

    assert_eq!(FONT.text_advance("AB"), 6);
    assert_eq!(FONT.text_width("AB"), 5);
}

#[test]
#[should_panic(expected = "storage is too small")]
fn rejects_small_storage() {
    let _ = FontBitmap::<u8>::new(&[], ' ', 5, 5, 4, 6, 6);
}

#[test]
#[rustfmt::skip]
fn draw_mono_fonts() {
    let mut buffer = [0u8; 15 * 4]; // Empty 1-bit buffer
    FONT_BIT_3_3.draw_mono(&mut buffer, 15, 2, 2, "LB");
    let expected = [
        0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, // row 1
        0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, // row 2
        0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, // row 3
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // row 4 (empty)
    ];
    assert_eq!(buffer, expected);

    let mut buffer = [0u8; 15 * 5]; // Empty 1-bit buffer
    FONT_BIT_3_5.draw_mono(&mut buffer, 15, 2, 4, "LIT");
    let expected = [
        0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, // row 1
        0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, // row 2
        0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, // row 3
        0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, // row 4
        0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, // row 5
    ];
    assert_eq!(buffer, expected);

    let mut buffer = [0u8; 20 * 7]; // Empty 1-bit buffer
    FONT_BIT_5_6.draw_mono(&mut buffer, 20, 2, 5, "LIT");
    let expected = [
        0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, // row 0
        0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, // row 2
        0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, // row 3
        0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, // row 4
        0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, // row 5
        0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, // row 6
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // row 7
    ];
    assert_eq!(buffer, expected);
}

#[test]
#[rustfmt::skip]
fn draw_mono_clipping() {
    const WIDTH: usize = 3;
    const HEIGHT: usize = 3;
    // IMPROVE: make a macro to pass the const literals for width and height
    fn assert_draw(font: &FontBitmap<u16>, x: isize, y: isize, expected: &[u8]) {
        let mut buffer = [0u8; WIDTH * HEIGHT];
        font.draw_mono(&mut buffer, WIDTH, x, y, "0");
        assert_eq!(buffer, expected);
    }
    assert_draw(&FONT_BIT_3_3, 0, 2, &[ 1,1,1, 1,0,1, 1,1,1 ]); // centered

    assert_draw(&FONT_BIT_3_3, 0, 1, &[ 1,0,1, 1,1,1, 0,0,0 ]); // up+1
    assert_draw(&FONT_BIT_3_3, 0, 0, &[ 1,1,1, 0,0,0, 0,0,0 ]); // up+2

    assert_draw(&FONT_BIT_3_3, 0, 3, &[ 0,0,0, 1,1,1, 1,0,1 ]); // down+1
    assert_draw(&FONT_BIT_3_3, 0, 4, &[ 0,0,0, 0,0,0, 1,1,1 ]); // down+2
    assert_draw(&FONT_BIT_3_3, 0, 5, &[ 0,0,0, 0,0,0, 0,0,0 ]); // down+3

    assert_draw(&FONT_BIT_3_3, 1, 2, &[ 0,1,1, 0,1,0, 0,1,1 ]); // right+1
    assert_draw(&FONT_BIT_3_3, 2, 2, &[ 0,0,1, 0,0,1, 0,0,1 ]); // right+2
    assert_draw(&FONT_BIT_3_3, 3, 2, &[ 0,0,0, 0,0,0, 0,0,0 ]); // right+3
}

#[test]
#[rustfmt::skip]
fn draw_rgba_clipping() {
    const WIDTH: usize = 3;
    const HEIGHT: usize = 3;
    let color = [255, 0, 0, 255];
    // Each pixel is 4 bytes, so our buffer size is WIDTH * HEIGHT * 4.
    let mut buffer = [0u8; WIDTH * HEIGHT * 4];

    // For FONT_BIT_3_3, baseline = 2.
    // Choosing y = 2 will map:
    //   glyph row 0 -> buffer row (2 + 0 - 2) = 0,
    //   glyph row 1 -> buffer row 1,
    //   glyph row 2 -> buffer row 2.
    FONT_BIT_3_3.draw_rgba(&mut buffer, WIDTH, 0, 2, "0", color);

    // Expected pattern for the "0" glyph:
    let expected: [u8; WIDTH * HEIGHT * 4] = [
        255, 0, 0, 255,  255, 0, 0, 255,  255, 0, 0, 255,
        255, 0, 0, 255,    0, 0, 0, 0,    255, 0, 0, 255,
        255, 0, 0, 255,  255, 0, 0, 255,  255, 0, 0, 255,
    ];
    assert_eq!(buffer, expected);
}