348 lines
13 KiB
Rust
348 lines
13 KiB
Rust
use rusttype::{point, Font, PositionedGlyph, Scale};
|
|
use std::convert::TryInto;
|
|
use std::io::Write;
|
|
|
|
// Add an allocator that lets us keep track of the system
|
|
extern crate stats_alloc;
|
|
use stats_alloc::{Region, StatsAlloc, INSTRUMENTED_SYSTEM};
|
|
use std::alloc::System;
|
|
#[global_allocator]
|
|
static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;
|
|
|
|
fn main() {
|
|
// Chinese test
|
|
// let font = include_bytes!("../resources/WenQuanYiMicroHei-01.ttf");
|
|
let font = include_bytes!("../resources/NotoSansSC-Regular.ttf");
|
|
let message = " 發啊你好";
|
|
let rtl = false;
|
|
println!();
|
|
println!("RUSTTYPE TEST:");
|
|
test_rusttype(font, message, rtl);
|
|
println!("RUSTTYPE + RUSTYBUZZ TEST:");
|
|
test_rusthbuzz(font, message);
|
|
|
|
// Arabic test
|
|
let font = include_bytes!("../resources/LateefRegOT.ttf");
|
|
let message = "مرحبا بالعالم "; // "Hello, world!"
|
|
// let message = "مممممم"; // Kerning test nonsense string
|
|
let rtl = true;
|
|
println!();
|
|
println!("RUSTTYPE TEST:");
|
|
test_rusttype(font, message, rtl);
|
|
|
|
println!("RUSTTYPE + RUSTYBUZZ TEST:");
|
|
test_rusthbuzz(font, message);
|
|
|
|
// Emoji Test
|
|
// let font = include_bytes!("../resources/TwitterColorEmoji-SVGinOT.ttf");
|
|
// let font = include_bytes!("../resources/Symbola-AjYx.ttf");
|
|
let font = include_bytes!("../resources/NotoEmoji-Regular.ttf");
|
|
let message = concat!(
|
|
"🐶🐱🦁🐎🦄🐷🐘🐰\n",
|
|
"🐼🐓🐧🐢🐟🐙🦋🌷\n",
|
|
"🌳🌵🍄🌏🌙☁️🔥🍌\n",
|
|
"🍎🍓🌽🍕🎂❤️😀🤖\n",
|
|
"🎩👓🔧🎅👍☂️⌛⏰\n",
|
|
"🎁💡📕✏️📎✂️🔒🔑\n",
|
|
"🔨☎️🏁🚂🚲✈️🚀🏆\n",
|
|
"⚽🎸🎺🔔⚓🎧📁📌\n",
|
|
"Hello, world! ää 🀄🃏\u{1F170}\u{1F170}\u{FE0F}\n",
|
|
// "🐶🐱🦁🐎🦄🐷🐘🐰🐼🐓🐧🐢🐟🐙🦋🌷🌳🌵🍄🌏🌙☁️🔥🍌🍎🍓🌽🍕🎂❤️😀🤖🎩👓🔧🎅👍☂️⌛⏰🎁💡📕✏️📎✂️🔒🔑🔨☎️🏁🚂🚲✈️🚀🏆⚽🎸🎺🔔⚓🎧📁📌"
|
|
);
|
|
println!();
|
|
println!("RUSTTYPE + RUSTYBUZZ TEST:");
|
|
|
|
test_rusthbuzz(font, message);
|
|
let font = include_bytes!("../resources/TwitterColorEmoji-SVGinOT.ttf");
|
|
println!();
|
|
println!("RUSTTYPE + RUSTYBUZZ TEST:");
|
|
test_rusthbuzz(font, message);
|
|
|
|
let font = include_bytes!("../resources/Symbola-AjYx.ttf");
|
|
println!();
|
|
println!("RUSTTYPE + RUSTYBUZZ TEST:");
|
|
test_rusthbuzz(font, message);
|
|
}
|
|
|
|
// fn test_fontdue(font: &[u8], message: &str, _rtl: bool) {
|
|
// let reg = Region::new(&GLOBAL);
|
|
// println!("start: {:#?}", reg.change());
|
|
|
|
// // Parse it into the font type.
|
|
// let font = fontdue::Font::from_bytes(font, fontdue::FontSettings::default()).unwrap();
|
|
// println!("from_bytes: {:#?}", reg.change());
|
|
|
|
// // Rasterize and get the layout metrics for the letter 'g' at 17px.
|
|
// let (metrics, bitmap) = font.rasterize(message.chars().nth(0).unwrap(), 17.0);
|
|
// println!("font.rasterize: {:#?}", reg.change());
|
|
|
|
// // Used here to ensure that the value is not
|
|
// // dropped before we check the statistics
|
|
// ::std::mem::size_of_val(&metrics);
|
|
// ::std::mem::size_of_val(&bitmap);
|
|
// ::std::mem::size_of_val(&font);
|
|
// }
|
|
|
|
fn test_rusthbuzz(font: &[u8], message: &str) {
|
|
const FB_WIDTH: usize = 336;
|
|
const FB_HEIGHT: usize = 536;
|
|
let rusttype_height = 32.0;
|
|
let mut buffer = vec![];
|
|
for _ in 0..FB_HEIGHT {
|
|
buffer.push(vec![0f32; FB_WIDTH]);
|
|
}
|
|
use minifb::{Key, Window, WindowOptions};
|
|
let mut window = Window::new(
|
|
"Betrusted",
|
|
FB_WIDTH,
|
|
FB_HEIGHT,
|
|
WindowOptions {
|
|
scale_mode: minifb::ScaleMode::AspectRatioStretch,
|
|
resize: true,
|
|
..WindowOptions::default()
|
|
},
|
|
)
|
|
.unwrap_or_else(|e| {
|
|
panic!("{}", e);
|
|
});
|
|
const DARK_COLOUR: u32 = 0xB5B5AD;
|
|
const LIGHT_COLOUR: u32 = 0x1B1B19;
|
|
let mut native_buffer = vec![LIGHT_COLOUR; FB_WIDTH * FB_HEIGHT];
|
|
|
|
let lines = message.split('\n');
|
|
|
|
let reg = Region::new(&GLOBAL);
|
|
|
|
let mut buzz_font = rustybuzz::Face::from_slice(font, 0).unwrap();
|
|
println!("buzz_font: {:#?}", reg.change());
|
|
buzz_font.set_pixels_per_em(Some((196, 196)));
|
|
|
|
let buzz_features = vec![];
|
|
println!("buzz_features: {:#?}", reg.change());
|
|
|
|
let mut buzz_buffer = rustybuzz::UnicodeBuffer::new();
|
|
println!("buzz_buffer: {:#?}", reg.change());
|
|
|
|
for (line_number, line) in lines.enumerate() {
|
|
buzz_buffer.push_str(line);
|
|
println!("buzz_buffer_push: {:#?}", reg.change());
|
|
|
|
let glyph_buffer = rustybuzz::shape(&buzz_font, &buzz_features, buzz_buffer);
|
|
println!("buzz_shape: {:#?}", reg.change());
|
|
|
|
let rusttype_font =
|
|
Font::try_from_bytes(font).expect("error constructing a Font from bytes");
|
|
println!("fonttype_collection: {:#?}", reg.change());
|
|
|
|
let mut cursor_x = 0.0;
|
|
let mut cursor_y = (line_number as f32) * rusttype_height;
|
|
|
|
let rusttype_scale = rusttype::Scale {
|
|
x: rusttype_height * 1.0,
|
|
y: rusttype_height,
|
|
};
|
|
// Adapt the harfbuzz scale to rusttype's scale.
|
|
// I'm not sure where the "1.2" comes from, but the units only *just* match.
|
|
let harfbuzz_scale = rusttype_font.units_per_em() as f32 / rusttype_height * 1.0 /* * 1.2 */;
|
|
|
|
let v_metrics = rusttype_font.v_metrics(rusttype_scale);
|
|
let offset = point(0.0, v_metrics.ascent);
|
|
|
|
// println!("font is {} units-per-em", rusttype_font.units_per_em());
|
|
for (buzz_info, buzz_position) in glyph_buffer
|
|
.glyph_infos()
|
|
.iter()
|
|
.zip(glyph_buffer.glyph_positions().iter())
|
|
{
|
|
// let codepoint_rs = char::try_from(buzz_info.codepoint).expect("invalid codepoint");
|
|
let font_glyph = rusttype_font.glyph(rusttype::GlyphId(
|
|
buzz_info
|
|
.glyph_id
|
|
.try_into()
|
|
.expect("codepoint out of range"),
|
|
));
|
|
let glyph_scaled = font_glyph.scaled(rusttype_scale);
|
|
|
|
let x_offset = buzz_position.x_offset as f32 / harfbuzz_scale;
|
|
let y_offset = buzz_position.y_offset as f32 / harfbuzz_scale;
|
|
let x_advance = buzz_position.x_advance as f32 / harfbuzz_scale;
|
|
let y_advance = buzz_position.y_advance as f32 / harfbuzz_scale;
|
|
|
|
let glyph_positioned = glyph_scaled.positioned(rusttype::Point {
|
|
x: (x_offset as f32) + offset.x,
|
|
y: (y_offset as f32) + offset.y,
|
|
});
|
|
|
|
if let Some(bb) = glyph_positioned.pixel_bounding_box() {
|
|
// println!(
|
|
// "Offset: {} / {}, {} / {} {}/{} {}/{}",
|
|
// x_offset, y_offset,
|
|
// x_advance, y_advance,
|
|
// cursor_x, cursor_y,
|
|
// bb.min.x, bb.min.y,
|
|
// );
|
|
glyph_positioned.draw(|x, y, weight| {
|
|
let x = (x as f32) + ((cursor_x + x_offset) as f32) + (bb.min.x as f32);
|
|
let y = (y as f32) + ((cursor_y + y_offset) as f32) + (bb.min.y as f32);
|
|
|
|
if (x < 0.0)
|
|
|| (x >= (buffer[0].len() as f32))
|
|
|| (y < 0.0)
|
|
|| (y >= (buffer.len() as f32))
|
|
{
|
|
// println!("(x,y) out of bounds: ({}, {})", x, y);
|
|
return;
|
|
}
|
|
let x = x as usize;
|
|
let y = y as usize;
|
|
// if y < buffer.len() && x < buffer[0].len() {
|
|
buffer[y][x] += weight;
|
|
// }
|
|
});
|
|
}
|
|
cursor_x += x_advance;
|
|
cursor_y += y_advance;
|
|
}
|
|
buzz_buffer = glyph_buffer.clear();
|
|
buzz_buffer.clear();
|
|
}
|
|
|
|
let mut offset = 0;
|
|
for line in &*buffer {
|
|
for pixel in line {
|
|
native_buffer[offset] = if pixel > &0.5 {
|
|
LIGHT_COLOUR
|
|
} else {
|
|
DARK_COLOUR
|
|
};
|
|
offset += 1;
|
|
}
|
|
}
|
|
window
|
|
.update_with_buffer(&native_buffer, FB_WIDTH, FB_HEIGHT)
|
|
.unwrap();
|
|
|
|
while window.is_open() && !window.is_key_down(Key::Escape) {
|
|
window.update();
|
|
}
|
|
// for y in (0..buffer.len() - 4).step_by(4) {
|
|
// for x in (0..buffer[y].len() - 2).step_by(2) {
|
|
// let mut offset = 0;
|
|
// let threshold = 0.5;
|
|
|
|
// if buffer[y + 0][x + 0] > threshold {
|
|
// offset |= 1 << 0;
|
|
// }
|
|
// if buffer[y + 1][x + 0] > threshold {
|
|
// offset |= 1 << 1;
|
|
// }
|
|
// if buffer[y + 2][x + 0] > threshold {
|
|
// offset |= 1 << 2;
|
|
// }
|
|
|
|
// if buffer[y + 0][x + 1] > threshold {
|
|
// offset |= 1 << 3;
|
|
// }
|
|
// if buffer[y + 1][x + 1] > threshold {
|
|
// offset |= 1 << 4;
|
|
// }
|
|
// if buffer[y + 2][x + 1] > threshold {
|
|
// offset |= 1 << 5;
|
|
// }
|
|
|
|
// if buffer[y + 3][x + 0] > threshold {
|
|
// offset |= 1 << 6;
|
|
// }
|
|
// if buffer[y + 3][x + 1] > threshold {
|
|
// offset |= 1 << 7;
|
|
// }
|
|
// let pixel_br = std::char::from_u32(0x2800 + offset).unwrap();
|
|
// print!("{}", pixel_br);
|
|
// }
|
|
// println!();
|
|
// }
|
|
}
|
|
|
|
fn test_rusttype(font: &[u8], message: &str, rtl: bool) {
|
|
let reg = Region::new(&GLOBAL);
|
|
|
|
let font = Font::try_from_bytes(font).expect("couldn't read font file");
|
|
|
|
// Desired font pixel height
|
|
let height: f32 = 20.0; // to get 80 chars across (fits most terminals); adjust as desired
|
|
let pixel_height = height.ceil() as usize;
|
|
|
|
// 2x scale in x direction to counter the aspect ratio of monospace characters.
|
|
let scale = Scale {
|
|
x: height * 2.0,
|
|
y: height,
|
|
};
|
|
|
|
// The origin of a line of text is at the baseline (roughly where
|
|
// non-descending letters sit). We don't want to clip the text, so we shift
|
|
// it down with an offset when laying it out. v_metrics.ascent is the
|
|
// distance between the baseline and the highest edge of any glyph in
|
|
// the font. That's enough to guarantee that there's no clipping.
|
|
let v_metrics = font.v_metrics(scale);
|
|
let offset = point(0.0, v_metrics.ascent);
|
|
println!("metrics: {:#?}", reg.change());
|
|
|
|
// Glyphs to draw for "RustType". Feel free to try other strings.
|
|
let glyphs: Vec<PositionedGlyph<'_>> = font.layout(message, scale, offset).collect();
|
|
println!("glyphs: {:#?}", reg.change());
|
|
|
|
// Find the most visually pleasing width to display
|
|
let width = glyphs
|
|
.iter()
|
|
.rev()
|
|
.map(|g| g.position().x as f32 + g.unpositioned().h_metrics().advance_width)
|
|
.next()
|
|
.unwrap_or(0.0)
|
|
.ceil() as usize;
|
|
|
|
println!("width: {}, height: {}", width, pixel_height);
|
|
|
|
// Rasterise directly into ASCII art.
|
|
let mut pixel_data = vec!['@'; width * pixel_height];
|
|
let mapping = [' ', '░', '▒', '▓', '█']; // The approximation of greyscale
|
|
let mapping_scale = (mapping.len() - 1) as f32;
|
|
for g in glyphs {
|
|
if let Some(bb) = g.pixel_bounding_box() {
|
|
g.draw(|x, y, v| {
|
|
// v should be in the range 0.0 to 1.0
|
|
let i = (v * mapping_scale + 0.5) as usize;
|
|
// so something's wrong if you get $ in the output.
|
|
let c = mapping.get(i).cloned().unwrap_or(' ');
|
|
let x = x as i32 + bb.min.x;
|
|
let y = y as i32 + bb.min.y;
|
|
// There's still a possibility that the glyph clips the boundaries of the bitmap
|
|
if x >= 0 && x < width as i32 && y >= 0 && y < pixel_height as i32 {
|
|
let x = if rtl {
|
|
width - (x as usize) - 1
|
|
} else {
|
|
x as usize
|
|
};
|
|
let y = y as usize;
|
|
pixel_data[(x + y * width)] = c;
|
|
}
|
|
})
|
|
}
|
|
}
|
|
println!("rasterization: {:#?}", reg.change());
|
|
|
|
// Print it out
|
|
let stdout = ::std::io::stdout();
|
|
let mut handle = stdout.lock();
|
|
for j in 0..pixel_height {
|
|
for px in pixel_data[j * width..(j + 1) * width].iter() {
|
|
let mut b = [0; 4];
|
|
px.encode_utf8(&mut b);
|
|
handle.write_all(&b).unwrap();
|
|
}
|
|
// handle
|
|
// .write_all(&b)
|
|
// .unwrap();
|
|
handle.write_all(b"\n").unwrap();
|
|
}
|
|
}
|