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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
//! Alacritty - The GPU Enhanced Terminal
#![feature(question_mark)]
#![feature(range_contains)]
#![feature(inclusive_range_syntax)]
#![feature(io)]
extern crate fontconfig;
extern crate freetype;
extern crate libc;
extern crate glutin;
extern crate cgmath;
extern crate euclid;
use std::collections::HashMap;
use std::io::{BufReader, Read, BufRead};
#[macro_use]
mod macros;
mod list_fonts;
mod text;
mod renderer;
mod grid;
mod meter;
mod tty;
mod ansi;
use renderer::{Glyph, QuadRenderer};
use text::FontDesc;
use grid::Grid;
mod gl {
include!(concat!(env!("OUT_DIR"), "/gl_bindings.rs"));
}
static INIT_LIST: &'static str = "abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ\
01234567890\
~`!@#$%^&*()[]{}-_=+\\|\"/?.,<>;:";
type GlyphCache = HashMap<String, renderer::Glyph>;
/// Render a string in a predefined location. Used for printing render time for profiling and
/// optimization.
fn render_string(s: &str,
renderer: &QuadRenderer,
glyph_cache: &GlyphCache,
cell_width: u32,
color: &renderer::Rgb)
{
let (mut x, mut y) = (200f32, 20f32);
for c in s.chars() {
let s: String = c.escape_default().collect();
if let Some(glyph) = glyph_cache.get(&s[..]) {
renderer.render(glyph, x, y, color);
}
x += cell_width as f32 + 2f32;
}
}
fn main() {
let window = glutin::Window::new().unwrap();
let (width, height) = window.get_inner_size_pixels().unwrap();
unsafe {
window.make_current().unwrap();
}
unsafe {
gl::load_with(|symbol| window.get_proc_address(symbol) as *const _);
gl::Viewport(0, 0, width as i32, height as i32);
}
let (dpi_x, dpi_y) = window.get_dpi().unwrap();
let dpr = window.hidpi_factor();
let font_size = 11.;
let sep_x = 2;
let sep_y = 5;
let desc = FontDesc::new("DejaVu Sans Mono", "Book");
let mut rasterizer = text::Rasterizer::new(dpi_x, dpi_y, dpr);
let (cell_width, cell_height) = rasterizer.box_size_for_font(&desc, font_size);
let num_cols = grid::num_cells_axis(cell_width, sep_x, width);
let num_rows = grid::num_cells_axis(cell_height, sep_y, height);
let mut cmd = tty::new(num_rows as u8, num_cols as u8);
::std::thread::spawn(move || {
for byte in cmd.bytes() {
let b = byte.unwrap();
println!("{:02x}, {:?}", b, ::std::char::from_u32(b as u32));
}
});
println!("num_cols, num_rows = {}, {}", num_cols, num_rows);
let mut grid = Grid::new(num_rows as usize, num_cols as usize);
// let contents = [
// "for (row, line) in contents.iter().enumerate() {",
// " for (i, c) in line.chars().enumerate() {",
// " grid[row][i] = grid::Cell::new(Some(c.escape_default().collect()));",
// " }",
// "}"];
let contents = include_str!("grid.rs");
let mut row = 0usize;
let mut col = 0;
for (i, c) in contents.chars().enumerate() {
if c == '\n' {
row += 1;
col = 0;
continue;
}
if row >= (num_rows as usize) {
break;
}
if col >= grid.cols() {
continue;
}
grid[row][col] = grid::Cell::new(c.escape_default().collect::<String>());
col += 1;
}
let mut glyph_cache = HashMap::new();
for c in INIT_LIST.chars() {
let glyph = Glyph::new(&rasterizer.get_glyph(&desc, font_size, c));
let string: String = c.escape_default().collect();
glyph_cache.insert(string, glyph);
}
unsafe {
gl::Enable(gl::BLEND);
gl::BlendFunc(gl::SRC1_COLOR, gl::ONE_MINUS_SRC1_COLOR);
gl::Enable(gl::MULTISAMPLE);
}
let renderer = QuadRenderer::new(width, height);
let mut meter = meter::Meter::new();
'main_loop: loop {
for event in window.poll_events() {
match event {
glutin::Event::Closed => break 'main_loop,
_ => ()
}
}
unsafe {
gl::ClearColor(0.0, 0.0, 0.00, 1.0);
gl::Clear(gl::COLOR_BUFFER_BIT);
}
{
let color = renderer::Rgb { r: 0.917, g: 0.917, b: 0.917 };
let _sampler = meter.sampler();
for i in 0..grid.rows() {
let row = &grid[i];
for j in 0..row.cols() {
let cell = &row[j];
if !cell.character.is_empty() {
if let Some(glyph) = glyph_cache.get(&cell.character[..]) {
let y = (cell_height as f32 + sep_y as f32) * (i as f32);
let x = (cell_width as f32 + sep_x as f32) * (j as f32);
let y_inverted = (height as f32) - y - (cell_height as f32);
renderer.render(glyph, x, y_inverted, &color);
}
}
}
}
}
let timing = format!("{:.3} usec", meter.average());
let color = renderer::Rgb { r: 0.835, g: 0.306, b: 0.325 };
render_string(&timing[..], &renderer, &glyph_cache, cell_width, &color);
window.swap_buffers().unwrap();
// ::std::thread::sleep(::std::time::Duration::from_millis(17));
}
}
|
