306 lines
11 KiB
Rust
306 lines
11 KiB
Rust
mod outline;
|
|
|
|
/// A point in device pixels from the cell's top-left.
|
|
pub type Point = (f32, f32);
|
|
|
|
/// A piece of a drawn character in device pixels from the cell's top-left; pieces never overlap.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Shape {
|
|
/// A rectangle filled at `alpha` of the text color.
|
|
Rect {
|
|
x: u32,
|
|
y: u32,
|
|
w: u32,
|
|
h: u32,
|
|
alpha: f32,
|
|
},
|
|
/// A simple polygon, filled.
|
|
Fill(Vec<Point>),
|
|
}
|
|
|
|
/// Whether the terminal draws `ch` as shapes instead of through the font.
|
|
pub fn drawn(ch: char) -> bool {
|
|
matches!(ch, '\u{2500}'..='\u{259F}' | '\u{E0B0}'..='\u{E0B7}')
|
|
}
|
|
|
|
const NONE: u8 = 0;
|
|
const LIGHT: u8 = 1;
|
|
const HEAVY: u8 = 2;
|
|
const DOUBLE: u8 = 3;
|
|
|
|
/// Each line character's arms, up, right, down, left, from U+2500.
|
|
#[rustfmt::skip]
|
|
const LINES: [[u8; 4]; 128] = [
|
|
[0, 1, 0, 1], [0, 2, 0, 2], [1, 0, 1, 0], [2, 0, 2, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
|
|
[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 0], [0, 2, 1, 0], [0, 1, 2, 0], [0, 2, 2, 0],
|
|
[0, 0, 1, 1], [0, 0, 1, 2], [0, 0, 2, 1], [0, 0, 2, 2], [1, 1, 0, 0], [1, 2, 0, 0], [2, 1, 0, 0], [2, 2, 0, 0],
|
|
[1, 0, 0, 1], [1, 0, 0, 2], [2, 0, 0, 1], [2, 0, 0, 2], [1, 1, 1, 0], [1, 2, 1, 0], [2, 1, 1, 0], [1, 1, 2, 0],
|
|
[2, 1, 2, 0], [2, 2, 1, 0], [1, 2, 2, 0], [2, 2, 2, 0], [1, 0, 1, 1], [1, 0, 1, 2], [2, 0, 1, 1], [1, 0, 2, 1],
|
|
[2, 0, 2, 1], [2, 0, 1, 2], [1, 0, 2, 2], [2, 0, 2, 2], [0, 1, 1, 1], [0, 1, 1, 2], [0, 2, 1, 1], [0, 2, 1, 2],
|
|
[0, 1, 2, 1], [0, 1, 2, 2], [0, 2, 2, 1], [0, 2, 2, 2], [1, 1, 0, 1], [1, 1, 0, 2], [1, 2, 0, 1], [1, 2, 0, 2],
|
|
[2, 1, 0, 1], [2, 1, 0, 2], [2, 2, 0, 1], [2, 2, 0, 2], [1, 1, 1, 1], [1, 1, 1, 2], [1, 2, 1, 1], [1, 2, 1, 2],
|
|
[2, 1, 1, 1], [1, 1, 2, 1], [2, 1, 2, 1], [2, 1, 1, 2], [2, 2, 1, 1], [1, 1, 2, 2], [1, 2, 2, 1], [2, 2, 1, 2],
|
|
[1, 2, 2, 2], [2, 1, 2, 2], [2, 2, 2, 1], [2, 2, 2, 2], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
|
|
[0, 3, 0, 3], [3, 0, 3, 0], [0, 3, 1, 0], [0, 1, 3, 0], [0, 3, 3, 0], [0, 0, 1, 3], [0, 0, 3, 1], [0, 0, 3, 3],
|
|
[1, 3, 0, 0], [3, 1, 0, 0], [3, 3, 0, 0], [1, 0, 0, 3], [3, 0, 0, 1], [3, 0, 0, 3], [1, 3, 1, 0], [3, 1, 3, 0],
|
|
[3, 3, 3, 0], [1, 0, 1, 3], [3, 0, 3, 1], [3, 0, 3, 3], [0, 3, 1, 3], [0, 1, 3, 1], [0, 3, 3, 3], [1, 3, 0, 3],
|
|
[3, 1, 0, 1], [3, 3, 0, 3], [1, 3, 1, 3], [3, 1, 3, 1], [3, 3, 3, 3], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
|
|
[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
|
|
[0, 0, 0, 2], [2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 0], [0, 2, 0, 1], [1, 0, 2, 0], [0, 1, 0, 2], [2, 0, 1, 0],
|
|
];
|
|
|
|
/// Quadrant blocks from U+2596: top-left, top-right, bottom-left, bottom-right bits.
|
|
const QUADRANTS: [u8; 10] = [
|
|
0b0010, 0b0001, 0b1000, 0b1011, 0b1001, 0b1110, 0b1101, 0b0100, 0b0110, 0b0111,
|
|
];
|
|
|
|
/// A box by its corners: left, top, right, bottom.
|
|
type Corners = [u32; 4];
|
|
|
|
/// The shapes of a `drawn` char in a `w` by `h` cell whose light lines are `t` thick.
|
|
pub fn shapes(ch: char, w: u32, h: u32, t: u32) -> Vec<Shape> {
|
|
let code = ch as u32;
|
|
match code {
|
|
0x2504..=0x250B | 0x254C..=0x254F => rects(dashes(code, w, h, t), 1.),
|
|
0x256D..=0x2570 => outline::arc(code, w, h, t),
|
|
0x2571..=0x2573 => outline::diagonals(code, w, h, t),
|
|
0x2500..=0x257F => rects(lines(LINES[(code - 0x2500) as usize], w, h, t), 1.),
|
|
0x2591..=0x2593 => rects(vec![[0, 0, w, h]], (code - 0x2590) as f32 / 4.),
|
|
0x2580..=0x259F => rects(blocks(code, w, h), 1.),
|
|
0xE0B0..=0xE0B7 => outline::powerline(code, w, h, t),
|
|
_ => panic!("U+{code:04X} is not a drawn character"),
|
|
}
|
|
}
|
|
|
|
/// Rects from boxes with their overlaps cut away, so each pixel takes the color once.
|
|
fn rects(boxes: Vec<Corners>, alpha: f32) -> Vec<Shape> {
|
|
let mut kept: Vec<Corners> = Vec::new();
|
|
for corners in boxes {
|
|
let mut pieces = vec![corners];
|
|
for seen in &kept {
|
|
pieces = pieces
|
|
.into_iter()
|
|
.flat_map(|piece| outside(piece, *seen))
|
|
.collect();
|
|
}
|
|
kept.extend(pieces);
|
|
}
|
|
kept.into_iter()
|
|
.filter(|[x0, y0, x1, y1]| x1 > x0 && y1 > y0)
|
|
.map(|[x0, y0, x1, y1]| Shape::Rect {
|
|
x: x0,
|
|
y: y0,
|
|
w: x1 - x0,
|
|
h: y1 - y0,
|
|
alpha,
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// The parts of `piece` outside `cut`.
|
|
fn outside(piece: Corners, cut: Corners) -> Vec<Corners> {
|
|
let ([x0, y0, x1, y1], [cx0, cy0, cx1, cy1]) = (piece, cut);
|
|
if cx0 >= x1 || cx1 <= x0 || cy0 >= y1 || cy1 <= y0 {
|
|
return vec![piece];
|
|
}
|
|
let (top, bottom) = (cy0.max(y0), cy1.min(y1));
|
|
[
|
|
[x0, y0, x1, top],
|
|
[x0, bottom, x1, y1],
|
|
[x0, top, cx0.max(x0), bottom],
|
|
[cx1.min(x1), top, x1, bottom],
|
|
]
|
|
.into_iter()
|
|
.filter(|[a, b, c, d]| c > a && d > b)
|
|
.collect()
|
|
}
|
|
|
|
/// Where an arm ends at the center, by the arms crossing it: `[heavy, double, light, short]`.
|
|
fn stop((a, b): (u8, u8), straight: bool, [heavy, double, light, short]: [u32; 4]) -> u32 {
|
|
if a == HEAVY || b == HEAVY {
|
|
heavy
|
|
} else if a != b || straight {
|
|
if a == DOUBLE || b == DOUBLE {
|
|
double
|
|
} else {
|
|
light
|
|
}
|
|
} else if a == NONE && b == NONE {
|
|
light
|
|
} else {
|
|
short
|
|
}
|
|
}
|
|
|
|
/// Arms from the center to the edges, joined as Ghostty joins them.
|
|
fn lines([up, right, down, left]: [u8; 4], w: u32, h: u32, t: u32) -> Vec<Corners> {
|
|
let heavy = 2 * t;
|
|
let h_light_top = h.saturating_sub(t) / 2;
|
|
let h_light_bottom = h_light_top + t;
|
|
let h_heavy_top = h.saturating_sub(heavy) / 2;
|
|
let h_heavy_bottom = h_heavy_top + heavy;
|
|
let h_double_top = h_light_top.saturating_sub(t);
|
|
let h_double_bottom = h_light_bottom + t;
|
|
let v_light_left = w.saturating_sub(t) / 2;
|
|
let v_light_right = v_light_left + t;
|
|
let v_heavy_left = w.saturating_sub(heavy) / 2;
|
|
let v_heavy_right = v_heavy_left + heavy;
|
|
let v_double_left = v_light_left.saturating_sub(t);
|
|
let v_double_right = v_light_right + t;
|
|
let up_bottom = stop(
|
|
(left, right),
|
|
down == up,
|
|
[h_heavy_bottom, h_double_bottom, h_light_bottom, h_light_top],
|
|
);
|
|
let down_top = stop(
|
|
(left, right),
|
|
up == down,
|
|
[h_heavy_top, h_double_top, h_light_top, h_light_bottom],
|
|
);
|
|
let left_right = stop(
|
|
(up, down),
|
|
left == right,
|
|
[v_heavy_right, v_double_right, v_light_right, v_light_left],
|
|
);
|
|
let right_left = stop(
|
|
(up, down),
|
|
right == left,
|
|
[v_heavy_left, v_double_left, v_light_left, v_light_right],
|
|
);
|
|
let (top_double, bottom_double) = (up == DOUBLE, down == DOUBLE);
|
|
let mut out = Vec::new();
|
|
match up {
|
|
LIGHT => out.push([v_light_left, 0, v_light_right, up_bottom]),
|
|
HEAVY => out.push([v_heavy_left, 0, v_heavy_right, up_bottom]),
|
|
DOUBLE => {
|
|
let end = |side| {
|
|
if side == DOUBLE {
|
|
h_light_top
|
|
} else {
|
|
up_bottom
|
|
}
|
|
};
|
|
out.push([v_double_left, 0, v_light_left, end(left)]);
|
|
out.push([v_light_right, 0, v_double_right, end(right)]);
|
|
}
|
|
_ => {}
|
|
}
|
|
match right {
|
|
LIGHT => out.push([right_left, h_light_top, w, h_light_bottom]),
|
|
HEAVY => out.push([right_left, h_heavy_top, w, h_heavy_bottom]),
|
|
DOUBLE => {
|
|
let start = |double| if double { v_light_right } else { right_left };
|
|
out.push([start(top_double), h_double_top, w, h_light_top]);
|
|
out.push([start(bottom_double), h_light_bottom, w, h_double_bottom]);
|
|
}
|
|
_ => {}
|
|
}
|
|
match down {
|
|
LIGHT => out.push([v_light_left, down_top, v_light_right, h]),
|
|
HEAVY => out.push([v_heavy_left, down_top, v_heavy_right, h]),
|
|
DOUBLE => {
|
|
let start = |side| {
|
|
if side == DOUBLE {
|
|
h_light_bottom
|
|
} else {
|
|
down_top
|
|
}
|
|
};
|
|
out.push([v_double_left, start(left), v_light_left, h]);
|
|
out.push([v_light_right, start(right), v_double_right, h]);
|
|
}
|
|
_ => {}
|
|
}
|
|
match left {
|
|
LIGHT => out.push([0, h_light_top, left_right, h_light_bottom]),
|
|
HEAVY => out.push([0, h_heavy_top, left_right, h_heavy_bottom]),
|
|
DOUBLE => {
|
|
let end = |double| if double { v_light_left } else { left_right };
|
|
out.push([0, h_double_top, end(top_double), h_light_top]);
|
|
out.push([0, h_light_bottom, end(bottom_double), h_double_bottom]);
|
|
}
|
|
_ => {}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Dashes that tile across cells; a cell too small for them takes a solid light line.
|
|
fn dashes(code: u32, w: u32, h: u32, t: u32) -> Vec<Corners> {
|
|
let wide = t.max(4);
|
|
let (count, thick, gap, vertical) = match code {
|
|
0x2504 => (3, t, wide, false),
|
|
0x2505 => (3, 2 * t, wide, false),
|
|
0x2506 => (3, t, wide, true),
|
|
0x2507 => (3, 2 * t, wide, true),
|
|
0x2508 => (4, t, wide, false),
|
|
0x2509 => (4, 2 * t, wide, false),
|
|
0x250A => (4, t, wide, true),
|
|
0x250B => (4, 2 * t, wide, true),
|
|
0x254C => (2, t, t, false),
|
|
0x254D => (2, 2 * t, 2 * t, false),
|
|
0x254E => (2, t, 2 * t, true),
|
|
_ => (2, 2 * t, 2 * t, true),
|
|
};
|
|
let (along, across) = if vertical { (h, w) } else { (w, h) };
|
|
if along < 2 * count {
|
|
let solid = if vertical {
|
|
[LIGHT, NONE, LIGHT, NONE]
|
|
} else {
|
|
[NONE, LIGHT, NONE, LIGHT]
|
|
};
|
|
return lines(solid, w, h, t);
|
|
}
|
|
let gap = gap.min(along / (2 * count));
|
|
let total = along - count * gap;
|
|
let (dash, mut extra) = (total / count, total % count);
|
|
let side = across.saturating_sub(thick) / 2;
|
|
let mut at = if vertical { 0 } else { gap / 2 };
|
|
(0..count)
|
|
.map(|_| {
|
|
let end = at + dash + u32::from(extra > 0);
|
|
extra = extra.saturating_sub(1);
|
|
let piece = if vertical {
|
|
[side, at, side + thick, end]
|
|
} else {
|
|
[at, side, end, side + thick]
|
|
};
|
|
at = end + gap;
|
|
piece
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Block elements but the shades: eighths, halves and quadrants.
|
|
fn blocks(code: u32, w: u32, h: u32) -> Vec<Corners> {
|
|
let part = |share: f32, side: u32| (side as f32 * share).round() as u32;
|
|
let eighths = |n: u32| n as f32 / 8.;
|
|
match code {
|
|
0x2580 => vec![[0, 0, w, part(0.5, h)]],
|
|
0x2581..=0x2587 => vec![[0, h - part(eighths(code - 0x2580), h), w, h]],
|
|
0x2588 => vec![[0, 0, w, h]],
|
|
0x2589..=0x258F => vec![[0, 0, part(eighths(0x2590 - code), w), h]],
|
|
0x2590 => vec![[w - part(0.5, w), 0, w, h]],
|
|
0x2594 => vec![[0, 0, w, part(0.125, h)]],
|
|
0x2595 => vec![[w - part(0.125, w), 0, w, h]],
|
|
_ => {
|
|
let bits = QUADRANTS[(code - 0x2596) as usize];
|
|
let (mx, my) = (part(0.5, w), part(0.5, h));
|
|
let (nx, ny) = (w - mx, h - my);
|
|
[
|
|
[0, 0, mx, my],
|
|
[nx, 0, w, my],
|
|
[0, ny, mx, h],
|
|
[nx, ny, w, h],
|
|
]
|
|
.into_iter()
|
|
.enumerate()
|
|
.filter(|(index, _)| bits & (0b1000 >> index) != 0)
|
|
.map(|(_, corners)| corners)
|
|
.collect()
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests;
|