raclettui 0.1.2

Build terminal-themed wayland layer shell applications with Rust.
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

use std::collections::HashMap;
use fontdue::{LineMetrics, Metrics};

use crate::colors::RaclettuiColor;

#[derive(Debug)]
pub struct TerminalBuffer {
    pub inner: Vec<u8>,
    // window width in px
    pub window_width: u32,
    // window height in px
    pub window_height: u32,
    pub font: fontdue::Font,
    // in px
    pub font_size: f32,
    pub cell_width: u32,
    pub cell_height: u32,
    pub cache: HashMap<char, (Metrics, Vec<u8>)>,
    pub line_metrics: LineMetrics,
}

impl TerminalBuffer {
    pub fn new(
        window_width: u32,
        window_height: u32,
        font: fontdue::Font,
        font_size: f32,
    ) -> Self
    {
        let m_metrics = font.metrics('M', font_size);
        let line_metrics = font.horizontal_line_metrics(font_size).unwrap();
        let cell_height = (line_metrics.ascent - line_metrics.descent + line_metrics.line_gap).ceil() as u32;
        let cell_width = m_metrics.width as u32;

        let inner = vec![0u8; (window_width * window_height * 4) as usize];

        Self {
            inner,
            window_width,
            window_height,
            font,
            font_size,
            cell_width,
            cell_height,
            cache: HashMap::<char, (Metrics, Vec<u8>)>::new(),
            line_metrics
        }
    }

    pub fn grid_dims(&self) -> (u32, u32) {
        let cols = self.window_width / self.cell_width;
        let rows = self.window_height / self.cell_height;
        (cols, rows)
    }

    pub fn window_size(&self) -> (u32, u32) {
        (self.window_width, self.window_height)
    }

    fn set_pixel(&mut self, x: u32, y: u32, color: &RaclettuiColor) {
        if x >= self.window_width {
            panic!("x out of range x: {}, y: {}", x, y)
        }
        if y >= self.window_height {
            panic!("y out of range x: {}, y: {}", x, y)
        }
        let value = color.to_rgba();

        let index = ((y * self.window_width + x) * 4) as usize;
        self.inner[index] = value.2;
        self.inner[index + 1] = value.1;
        self.inner[index + 2] = value.0;
        self.inner[index + 3] = value.3;
    }

    // clears whole buffer with a color
    pub fn clear(&mut self, color: &RaclettuiColor) {
        for i in 0..self.window_height {
            for j in 0..self.window_width {
                self.set_pixel(j, i, color);
            }
        }
    }

    // sets background at a cell
    pub fn set_bg_at_cell(&mut self, x: u32, y: u32, color: &RaclettuiColor) {
        let cell_px_x = x * self.cell_width;
        let cell_px_y = y * self.cell_height;

        for i in 0..self.cell_height {
            for j in 0..self.cell_width {
                self.set_pixel(j + cell_px_x, i + cell_px_y, color);
            }
        }
    }

    // draws a character at a cell, not that background needs prior setting
    pub fn set_char_at_cell(&mut self, ch: char, x: u32, y: u32, color: &RaclettuiColor) {
        let color = color.to_rgba();
        if !self.cache.contains_key(&ch) {
            let val = self.font.rasterize(ch, self.font_size);
            self.cache.insert(ch, val);
        }
        let (metrics, bitmap) = &self.cache.get(&ch).unwrap().clone();


        let cell_px_x = x * self.cell_width;
        let cell_px_y = y * self.cell_height;

        let baseline_offset = (self.line_metrics.ascent).ceil() as i32;

        let glyph_x = cell_px_x as i32 + metrics.xmin;
        let glyph_y = cell_px_y as i32 + baseline_offset - metrics.height as i32 - metrics.ymin;
        let metrics_height = metrics.height;
        let metrics_width = metrics.width;

        for y in 0..metrics_height {
            for x in 0..metrics_width {
                let alpha = bitmap[y * metrics_width + x];
                if alpha == 0 {
                    continue;
                }

                let px = glyph_x + x as i32;
                let py = glyph_y + y as i32;

                if px < 0 ||
                    py < 0 ||
                    px >= self.window_width as i32 ||
                    py >= self.window_height as i32
                {
                    continue;
                }

                let alpha_f = alpha as f32 / 255.0;

                let r = (color.0 as f32 * alpha_f) as u8;
                let g = (color.1 as f32 * alpha_f) as u8;
                let b = (color.2 as f32 * alpha_f) as u8;

                self.set_pixel(
                    px as u32,
                    py as u32,
                    &RaclettuiColor::from_rgb(r, g, b),
                );

            }
        }
    }
}