glerminal 0.3.0

A lightweight OpenGL terminal
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

use std::cell::Cell;

use super::{Program, Renderable, Texture, Vao, Vbo};
use crate::text_buffer::TextBuffer;

pub(crate) struct BackgroundMesh {
    width: u32,
    height: u32,
    vbo_pos: Vbo,
    vbo_col: Vbo,
    vao: Vao,
    count: Cell<i32>,
}

impl Renderable for BackgroundMesh {
    fn get_vao(&self) -> Vao {
        self.vao
    }

    fn get_count(&self) -> i32 {
        self.count.get()
    }

    fn get_texture(&self) -> Option<Texture> {
        None
    }
}

impl BackgroundMesh {
    pub fn new(program: Program, dimensions: (u32, u32)) -> BackgroundMesh {
        let (width, height) = dimensions;

        let mut vertex_buffer_pos = Vec::new();

        let character_width = 1.0 / width as f32;
        let character_height = 1.0 / height as f32;
        for y in 0..height {
            for x in 0..width {
                let x_off = x as f32 * character_width;
                let y_off = y as f32 * character_height;
                let mut single_character_vbuff = vec![
                    x_off,
                    y_off + character_height,
                    x_off + character_width,
                    y_off + character_height,
                    x_off,
                    y_off,
                    x_off + character_width,
                    y_off,
                    x_off,
                    y_off,
                    x_off + character_width,
                    y_off + character_height,
                ];
                vertex_buffer_pos.append(&mut single_character_vbuff);
            }
        }

        let vertex_buffer_col = vec![0.0; (width * height * 24) as usize];
        let vertex_buffer_shakiness = vec![0.0; (width * height * 6) as usize];

        let vbo_pos = super::create_vbo(&vertex_buffer_pos);
        let vbo_col = super::create_vbo(&vertex_buffer_col);
        let vbo_shakiness = super::create_vbo(&vertex_buffer_shakiness);
        let vao = super::create_vao(program, vbo_pos, vbo_col, vbo_shakiness, None);

        let count = (width * height * 6) as i32;

        BackgroundMesh {
            width: width,
            height: height,
            vbo_pos: vbo_pos,
            vbo_col: vbo_col,
            vao: vao,
            count: Cell::new(count),
        }
    }

    pub fn update(&self, text_buffer: &TextBuffer) {
        if (text_buffer.height * text_buffer.width) as usize != text_buffer.chars.len() {
            panic!("Given TextBuffer height/width do not math chars.len()");
        }

        // Create new color vertex buffer
        let mut vertex_buffer_pos: Vec<f32> = Vec::new();

        // Create new color vertex buffer
        let mut vertex_buffer_col: Vec<f32> = Vec::new();

        let character_width = 1.0 / self.width as f32;
        let character_height = 1.0 / self.height as f32;
        for y in 0..text_buffer.height {
            for x in 0..text_buffer.width {
                let character = text_buffer.get_character(x, y).unwrap();

                if character.style.bg_color == [0.0; 4] {
                    continue;
                }

                // New Vertex Buffers
                let x_off = x as f32 * character_width;
                let y_off = y as f32 * character_height;
                let mut single_character_vbuff = vec![
                    x_off,
                    y_off + character_height,
                    x_off + character_width,
                    y_off + character_height,
                    x_off,
                    y_off,
                    x_off + character_width,
                    y_off,
                    x_off,
                    y_off,
                    x_off + character_width,
                    y_off + character_height,
                ];
                vertex_buffer_pos.append(&mut single_character_vbuff);

                // Get colors
                for _ in 0..6 {
                    vertex_buffer_col.append(&mut character.style.bg_color.to_vec());
                }
            }
        }

        self.count.set((vertex_buffer_pos.len() * 6) as i32);

        super::upload_buffer(self.vbo_pos, &vertex_buffer_pos);
        super::upload_buffer(self.vbo_col, &vertex_buffer_col);
    }
}