Applied-Software/ghostty
5
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2025-07-14 15:56:13 +03:00
Code Issues Packages Projects Releases Wiki Activity

font/sprite: cleanup branch drawing character impl, implement fade-out lines

Browse Source
This commit is contained in:
Qwerasd
2024-11-06 18:27:22 -05:00
parent 0441987346
commit 4dbf404dc3
3 changed files with 371 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

619
src/font/sprite/Box.zig
View File

@ -79,13 +79,15 @@ const Quads = packed struct(u4) {
br: bool = false,
};
/// Specification of a git branch node, which can have any of
/// 4 lines connecting to it in vertical or horizontal alignment
const NodeAlign = packed struct(u4) {
/// Specification of a branch drawing node, which consists of a
/// circle which is either empty or filled, and lines connecting
/// optionally between the circle and each of the 4 edges.
const BranchNode = packed struct(u5) {
up: bool = false,
right: bool = false,
down: bool = false,
left: bool = false,
right: bool = false,
filled: bool = false,
};
/// Alignment of a figure within a cell
@ -483,14 +485,14 @@ fn draw(self: Box, alloc: Allocator, canvas: *font.sprite.Canvas, cp: u32) !void
// '╬'
0x256c => self.draw_lines(canvas, .{ .up = .double, .down = .double, .left = .double, .right = .double }),
// '╭'
0x256d => try self.draw_light_arc(canvas, .br),
0x256d => try self.draw_arc(canvas, .br, .light),
// '╮'
0x256e => try self.draw_light_arc(canvas, .bl),
0x256e => try self.draw_arc(canvas, .bl, .light),
// '╯'
0x256f => try self.draw_light_arc(canvas, .tl),
0x256f => try self.draw_arc(canvas, .tl, .light),
// '╰'
0x2570 => try self.draw_light_arc(canvas, .tr),
0x2570 => try self.draw_arc(canvas, .tr, .light),
// '╱'
0x2571 => self.draw_light_diagonal_upper_right_to_lower_left(canvas),
// '╲'
@ -1311,319 +1313,329 @@ fn draw(self: Box, alloc: Allocator, canvas: *font.sprite.Canvas, cp: u32) !void
// '🯯'
0x1fbef => self.draw_circle(canvas, Alignment.top_left, true),
// (Below:)
// Branch drawing character set, used for drawing git-like
// graphs in the terminal. Originally implemented in Kitty.
// Ref:
// - https://github.com/kovidgoyal/kitty/pull/7681
// - https://github.com/kovidgoyal/kitty/pull/7805
// NOTE: Kitty is GPL licensed, and its code was not referenced
// for these characters, only the loose specification of
// the character set in the pull request descriptions.
//
// TODO(qwerasd): This should be in another file, but really the
// general organization of the sprite font code
// needs to be reworked eventually.
//
//
//
//
//
// ''
0x0f5d0 => self.hline_middle(canvas, Thickness.light),
0x0f5d0 => self.hline_middle(canvas, .light),
// ''
0x0f5d1 => self.vline_middle(canvas, Thickness.light),
0x0f5d1 => self.vline_middle(canvas, .light),
// ''
// 0x0f5d2 => self.draw_dash_fading(canvas, 4, Direction.LEFT, Thickness.light.height(self.thickness)),
0x0f5d2 => self.draw_fading_line(canvas, .right, .light),
// ''
// 0x0f5d3 => self.draw_dash_fading(canvas, 4, Direction.RIGHT, Thickness.light.height(self.thickness)),
0x0f5d3 => self.draw_fading_line(canvas, .left, .light),
// ''
// 0x0f5d4 => self.draw_dash_fading(canvas, 5, Direction.UP, Thickness.light.height(self.thickness)),
0x0f5d4 => self.draw_fading_line(canvas, .bottom, .light),
// ''
// 0x0f5d5 => self.draw_dash_fading(canvas, 5, Direction.DOWN, Thickness.light.height(self.thickness)),
0x0f5d5 => self.draw_fading_line(canvas, .top, .light),
// ''
0x0f5d6 => try self.draw_light_arc(canvas, .br),
0x0f5d6 => try self.draw_arc(canvas, .br, .light),
// ''
0x0f5d7 => try self.draw_light_arc(canvas, .bl),
0x0f5d7 => try self.draw_arc(canvas, .bl, .light),
// ''
0x0f5d8 => try self.draw_light_arc(canvas, .tr),
0x0f5d8 => try self.draw_arc(canvas, .tr, .light),
// ''
0x0f5d9 => try self.draw_light_arc(canvas, .tl),
0x0f5d9 => try self.draw_arc(canvas, .tl, .light),
// ''
0x0f5da => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tr);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .tr, .light);
},
// ''
0x0f5db => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .br);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .br, .light);
},
// ''
0x0f5dc => {
try self.draw_light_arc(canvas, .tr);
try self.draw_light_arc(canvas, .br);
try self.draw_arc(canvas, .tr, .light);
try self.draw_arc(canvas, .br, .light);
},
// ''
0x0f5dd => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tl);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .tl, .light);
},
// ''
0x0f5de => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .bl);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .bl, .light);
},
// ''
0x0f5df => {
try self.draw_light_arc(canvas, .tl);
try self.draw_light_arc(canvas, .bl);
try self.draw_arc(canvas, .tl, .light);
try self.draw_arc(canvas, .bl, .light);
},
// ''
0x0f5e0 => {
try self.draw_light_arc(canvas, .bl);
self.hline_middle(canvas, Thickness.light);
try self.draw_arc(canvas, .bl, .light);
self.hline_middle(canvas, .light);
},
// ''
0x0f5e1 => {
try self.draw_light_arc(canvas, .br);
self.hline_middle(canvas, Thickness.light);
try self.draw_arc(canvas, .br, .light);
self.hline_middle(canvas, .light);
},
// ''
0x0f5e2 => {
try self.draw_light_arc(canvas, .br);
try self.draw_light_arc(canvas, .bl);
try self.draw_arc(canvas, .br, .light);
try self.draw_arc(canvas, .bl, .light);
},
// ''
0x0f5e3 => {
try self.draw_light_arc(canvas, .tl);
self.hline_middle(canvas, Thickness.light);
try self.draw_arc(canvas, .tl, .light);
self.hline_middle(canvas, .light);
},
// ''
0x0f5e4 => {
try self.draw_light_arc(canvas, .tr);
self.hline_middle(canvas, Thickness.light);
try self.draw_arc(canvas, .tr, .light);
self.hline_middle(canvas, .light);
},
// ''
0x0f5e5 => {
try self.draw_light_arc(canvas, .tr);
try self.draw_light_arc(canvas, .tl);
try self.draw_arc(canvas, .tr, .light);
try self.draw_arc(canvas, .tl, .light);
},
// ''
0x0f5e6 => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tl);
try self.draw_light_arc(canvas, .tr);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .tl, .light);
try self.draw_arc(canvas, .tr, .light);
},
// ''
0x0f5e7 => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .bl);
try self.draw_light_arc(canvas, .br);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .bl, .light);
try self.draw_arc(canvas, .br, .light);
},
// ''
0x0f5e8 => {
self.hline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .bl);
try self.draw_light_arc(canvas, .tl);
self.hline_middle(canvas, .light);
try self.draw_arc(canvas, .bl, .light);
try self.draw_arc(canvas, .tl, .light);
},
// ''
0x0f5e9 => {
self.hline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tr);
try self.draw_light_arc(canvas, .br);
self.hline_middle(canvas, .light);
try self.draw_arc(canvas, .tr, .light);
try self.draw_arc(canvas, .br, .light);
},
// ''
0x0f5ea => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tl);
try self.draw_light_arc(canvas, .br);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .tl, .light);
try self.draw_arc(canvas, .br, .light);
},
// ''
0x0f5eb => {
self.vline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tr);
try self.draw_light_arc(canvas, .bl);
self.vline_middle(canvas, .light);
try self.draw_arc(canvas, .tr, .light);
try self.draw_arc(canvas, .bl, .light);
},
// ''
0x0f5ec => {
self.hline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tl);
try self.draw_light_arc(canvas, .br);
self.hline_middle(canvas, .light);
try self.draw_arc(canvas, .tl, .light);
try self.draw_arc(canvas, .br, .light);
},
// ''
0x0f5ed => {
self.hline_middle(canvas, Thickness.light);
try self.draw_light_arc(canvas, .tr);
try self.draw_light_arc(canvas, .bl);
self.hline_middle(canvas, .light);
try self.draw_arc(canvas, .tr, .light);
try self.draw_arc(canvas, .bl, .light);
},
// ''
0x0f5ee => self.draw_git_node(canvas, .{}, Thickness.light, true),
0x0f5ee => self.draw_branch_node(canvas, .{ .filled = true }, .light),
// ''
0x0f5ef => self.draw_git_node(canvas, .{}, Thickness.light, false),
0x0f5ef => self.draw_branch_node(canvas, .{}, .light),
// ''
0x0f5f0 => {
self.draw_git_node(canvas, .{ .right = true }, Thickness.light, true);
},
0x0f5f0 => self.draw_branch_node(canvas, .{
.right = true,
.filled = true,
}, .light),
// ''
0x0f5f1 => {
self.draw_git_node(canvas, .{ .right = true }, Thickness.light, false);
},
0x0f5f1 => self.draw_branch_node(canvas, .{
.right = true,
}, .light),
// ''
0x0f5f2 => {
self.draw_git_node(canvas, .{ .left = true }, Thickness.light, true);
},
0x0f5f2 => self.draw_branch_node(canvas, .{
.left = true,
.filled = true,
}, .light),
// ''
0x0f5f3 => {
self.draw_git_node(canvas, .{ .left = true }, Thickness.light, false);
},
0x0f5f3 => self.draw_branch_node(canvas, .{
.left = true,
}, .light),
// ''
0x0f5f4 => {
self.draw_git_node(canvas, .{ .left = true, .right = true }, Thickness.light, true);
},
0x0f5f4 => self.draw_branch_node(canvas, .{
.left = true,
.right = true,
.filled = true,
}, .light),
// ''
0x0f5f5 => {
self.draw_git_node(canvas, .{ .left = true, .right = true }, Thickness.light, false);
},
0x0f5f5 => self.draw_branch_node(canvas, .{
.left = true,
.right = true,
}, .light),
// ''
0x0f5f6 => {
self.draw_git_node(canvas, .{ .down = true }, Thickness.light, true);
},
0x0f5f6 => self.draw_branch_node(canvas, .{
.down = true,
.filled = true,
}, .light),
// ''
0x0f5f7 => {
self.draw_git_node(canvas, .{ .down = true }, Thickness.light, false);
},
0x0f5f7 => self.draw_branch_node(canvas, .{
.down = true,
}, .light),
// ''
0x0f5f8 => {
self.draw_git_node(canvas, .{ .up = true }, Thickness.light, true);
},
0x0f5f8 => self.draw_branch_node(canvas, .{
.up = true,
.filled = true,
}, .light),
// ''
0x0f5f9 => {
self.draw_git_node(canvas, .{ .up = true }, Thickness.light, false);
},
0x0f5f9 => self.draw_branch_node(canvas, .{
.up = true,
}, .light),
// ''
0x0f5fa => {
self.draw_git_node(canvas, .{ .up = true, .down = true }, Thickness.light, true);
},
0x0f5fa => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
.filled = true,
}, .light),
// ''
0x0f5fb => {
self.draw_git_node(canvas, .{ .up = true, .down = true }, Thickness.light, false);
},
0x0f5fb => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
}, .light),
// ''
0x0f5fc => {
self.draw_git_node(canvas, .{ .right = true, .down = true }, Thickness.light, true);
},
0x0f5fc => self.draw_branch_node(canvas, .{
.right = true,
.down = true,
.filled = true,
}, .light),
// ''
0x0f5fd => {
self.draw_git_node(canvas, .{ .right = true, .down = true }, Thickness.light, false);
},
0x0f5fd => self.draw_branch_node(canvas, .{
.right = true,
.down = true,
}, .light),
// ''
0x0f5fe => {
self.draw_git_node(canvas, .{ .left = true, .down = true }, Thickness.light, true);
},
0x0f5fe => self.draw_branch_node(canvas, .{
.left = true,
.down = true,
.filled = true,
}, .light),
// ''
0x0f5ff => {
self.draw_git_node(canvas, .{ .left = true, .down = true }, Thickness.light, false);
},
0x0f5ff => self.draw_branch_node(canvas, .{
.left = true,
.down = true,
}, .light),
// ''
0x0f600 => {
self.draw_git_node(canvas, .{ .up = true, .right = true }, Thickness.light, true);
},
0x0f600 => self.draw_branch_node(canvas, .{
.up = true,
.right = true,
.filled = true,
}, .light),
// ''
0x0f601 => {
self.draw_git_node(canvas, .{ .up = true, .right = true }, Thickness.light, false);
},
0x0f601 => self.draw_branch_node(canvas, .{
.up = true,
.right = true,
}, .light),
// ''
0x0f602 => {
self.draw_git_node(canvas, .{ .up = true, .left = true }, Thickness.light, true);
},
0x0f602 => self.draw_branch_node(canvas, .{
.up = true,
.left = true,
.filled = true,
}, .light),
// ''
0x0f603 => {
self.draw_git_node(canvas, .{ .up = true, .left = true }, Thickness.light, false);
},
0x0f603 => self.draw_branch_node(canvas, .{
.up = true,
.left = true,
}, .light),
// ''
0x0f604 => {
self.draw_git_node(canvas, .{ .up = true, .down = true, .right = true }, Thickness.light, true);
},
0x0f604 => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
.right = true,
.filled = true,
}, .light),
// ''
0x0f605 => {
self.draw_git_node(canvas, .{ .up = true, .down = true, .right = true }, Thickness.light, false);
},
0x0f605 => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
.right = true,
}, .light),
// ''
0x0f606 => {
self.draw_git_node(canvas, .{ .up = true, .down = true, .left = true }, Thickness.light, true);
},
0x0f606 => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
.left = true,
.filled = true,
}, .light),
// ''
0x0f607 => {
self.draw_git_node(canvas, .{ .up = true, .down = true, .left = true }, Thickness.light, false);
},
0x0f607 => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
.left = true,
}, .light),
// ''
0x0f608 => {
self.draw_git_node(canvas, .{ .down = true, .left = true, .right = true }, Thickness.light, true);
},
0x0f608 => self.draw_branch_node(canvas, .{
.down = true,
.left = true,
.right = true,
.filled = true,
}, .light),
// ''
0x0f609 => {
self.draw_git_node(canvas, .{ .down = true, .left = true, .right = true }, Thickness.light, false);
},
0x0f609 => self.draw_branch_node(canvas, .{
.down = true,
.left = true,
.right = true,
}, .light),
// ''
0x0f60a => {
self.draw_git_node(canvas, .{ .up = true, .left = true, .right = true }, Thickness.light, true);
},
0x0f60a => self.draw_branch_node(canvas, .{
.up = true,
.left = true,
.right = true,
.filled = true,
}, .light),
// ''
0x0f60b => {
self.draw_git_node(canvas, .{ .up = true, .left = true, .right = true }, Thickness.light, false);
},
0x0f60b => self.draw_branch_node(canvas, .{
.up = true,
.left = true,
.right = true,
}, .light),
// ''
0x0f60c => {
self.draw_git_node(canvas, .{ .up = true, .down = true, .left = true, .right = true }, Thickness.light, true);
},
0x0f60c => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
.left = true,
.right = true,
.filled = true,
}, .light),
// ''
0x0f60d => {
self.draw_git_node(canvas, .{ .up = true, .down = true, .left = true, .right = true }, Thickness.light, false);
},
0x0f60d => self.draw_branch_node(canvas, .{
.up = true,
.down = true,
.left = true,
.right = true,
}, .light),
// Not official box characters but special characters we hide
// in the high bits of a unicode codepoint.
@ -2116,21 +2128,98 @@ fn draw_cell_diagonal(
) catch {};
}
fn draw_git_node(
fn draw_fading_line(
self: Box,
canvas: *font.sprite.Canvas,
comptime nodes: NodeAlign,
comptime to: Edge,
comptime thickness: Thickness,
comptime filled: bool,
) void {
const thick_px = thickness.height(self.thickness);
const float_width: f64 = @floatFromInt(self.width);
const float_height: f64 = @floatFromInt(self.height);
const x: f64 = float_width / 2;
const y: f64 = float_height / 2;
// Top of horizontal strokes
const h_top = (self.height -| thick_px) / 2;
// Bottom of horizontal strokes
const h_bottom = h_top +| thick_px;
// Left of vertical strokes
const v_left = (self.width -| thick_px) / 2;
// Right of vertical strokes
const v_right = v_left +| thick_px;
// we need at least 1px leeway to see node + right/left line
const r: f64 = 0.47 * @min(float_width, float_height);
// If we're fading to the top or left, we start with 0.0
// and increment up as we progress, otherwise we start
// at 255.0 and increment down (negative).
var color: f64 = switch (to) {
.top, .left => 0.0,
.bottom, .right => 255.0,
};
const inc: f64 = 255.0 / switch (to) {
.top => float_height,
.bottom => -float_height,
.left => float_width,
.right => -float_width,
};
switch (to) {
.top, .bottom => {
for (0..self.height) |y| {
for (v_left..v_right) |x| {
canvas.pixel(
@intCast(x),
@intCast(y),
@enumFromInt(@as(u8, @intFromFloat(@round(color)))),
);
}
color += inc;
}
},
.left, .right => {
for (0..self.width) |x| {
for (h_top..h_bottom) |y| {
canvas.pixel(
@intCast(x),
@intCast(y),
@enumFromInt(@as(u8, @intFromFloat(@round(color)))),
);
}
color += inc;
}
},
}
}
fn draw_branch_node(
self: Box,
canvas: *font.sprite.Canvas,
node: BranchNode,
comptime thickness: Thickness,
) void {
const thick_px = thickness.height(self.thickness);
const float_width: f64 = @floatFromInt(self.width);
const float_height: f64 = @floatFromInt(self.height);
const float_thick: f64 = @floatFromInt(thick_px);
// Top of horizontal strokes
const h_top = (self.height -| thick_px) / 2;
// Bottom of horizontal strokes
const h_bottom = h_top +| thick_px;
// Left of vertical strokes
const v_left = (self.width -| thick_px) / 2;
// Right of vertical strokes
const v_right = v_left +| thick_px;
// We calculate the center of the circle this way
// to ensure it aligns with box drawing characters
// since the lines are sometimes off center to
// make sure they aren't split between pixels.
const cx: f64 = @as(f64, @floatFromInt(v_left)) + float_thick / 2;
const cy: f64 = @as(f64, @floatFromInt(h_top)) + float_thick / 2;
// The radius needs to be the smallest distance from the center to an edge.
const r: f64 = @min(
@min(cx, cy),
@min(float_width - cx, float_height - cy),
);
var ctx: z2d.Context = .{
.surface = canvas.sfc,
@ -2139,29 +2228,30 @@ fn draw_git_node(
.pixel = .{ .alpha8 = .{ .a = @intFromEnum(Shade.on) } },
},
},
.line_width = @floatFromInt(thickness.height(self.thickness)),
.line_width = float_thick,
};
var path = z2d.Path.init(canvas.alloc);
defer path.deinit();
const int_radius: u32 = @intFromFloat(r);
// These @intFromFloat casts shouldn't ever fail since r can never
// be greater than cx or cy, so when subtracting it from them the
// result can never be negative.
if (node.up)
self.rect(canvas, v_left, 0, v_right, @intFromFloat(@ceil(cy - r)));
if (node.right)
self.rect(canvas, @intFromFloat(@floor(cx + r)), h_top, self.width, h_bottom);
if (node.down)
self.rect(canvas, v_left, @intFromFloat(@floor(cy + r)), v_right, self.height);
if (node.left)
self.rect(canvas, 0, h_top, @intFromFloat(@ceil(cx - r)), h_bottom);
if (nodes.up)
self.vline_middle_xy(canvas, 0, (self.height / 2) - int_radius, self.width, thickness);
if (nodes.down)
self.vline_middle_xy(canvas, (self.height / 2) + int_radius, self.height, self.width, thickness);
if (nodes.left)
self.hline_middle_xy(canvas, 0, (self.width / 2) - int_radius, self.height, thickness);
if (nodes.right)
self.hline_middle_xy(canvas, (self.width / 2) + int_radius, self.width, self.height, thickness);
if (filled) {
path.arc(x, y, r, 0, std.math.pi * 2, false, null) catch return;
if (node.filled) {
path.arc(cx, cy, r, 0, std.math.pi * 2, false, null) catch return;
path.close() catch return;
ctx.fill(canvas.alloc, path) catch return;
} else {
path.arc(x, y, r - ctx.line_width / 2, 0, std.math.pi * 2, false, null) catch return;
path.arc(cx, cy, r - float_thick / 2, 0, std.math.pi * 2, false, null) catch return;
path.close() catch return;
ctx.stroke(canvas.alloc, path) catch return;
}
@ -2492,12 +2582,13 @@ fn draw_edge_triangle(
try ctx.fill(canvas.alloc, path);
}
fn draw_light_arc(
fn draw_arc(
self: Box,
canvas: *font.sprite.Canvas,
comptime corner: Corner,
comptime thickness: Thickness,
) !void {
const thick_px = Thickness.light.height(self.thickness);
const thick_px = thickness.height(self.thickness);
const float_width: f64 = @floatFromInt(self.width);
const float_height: f64 = @floatFromInt(self.height);
const float_thick: f64 = @floatFromInt(thick_px);
@ -2751,16 +2842,6 @@ fn draw_cursor_bar(self: Box, canvas: *font.sprite.Canvas) void {
self.vline(canvas, 0, self.height, 0, thick_px);
}
fn vline_middle_xy(self: Box, canvas: *font.sprite.Canvas, y: u32, y2: u32, x: u32, thickness: Thickness) void {
const thick_px = thickness.height(self.thickness);
self.vline(canvas, y, y2, (x -| thick_px) / 2, thick_px);
}
fn hline_middle_xy(self: Box, canvas: *font.sprite.Canvas, x: u32, x2: u32, y: u32, thickness: Thickness) void {
const thick_px = thickness.height(self.thickness);
self.hline(canvas, x, x2, (y -| thick_px) / 2, thick_px);
}
fn vline_middle(self: Box, canvas: *font.sprite.Canvas, thickness: Thickness) void {
const thick_px = thickness.height(self.thickness);
self.vline(canvas, 0, self.height, (self.width -| thick_px) / 2, thick_px);
@ -2864,20 +2945,6 @@ fn testRenderAll(self: Box, alloc: Allocator, atlas: *font.Atlas) !void {
);
}
// Git Branch characters
cp = 0xf5d0;
while (cp <= 0xf60d) : (cp += 1) {
switch (cp) {
0xf5d0...0xf60d,
=> _ = try self.renderGlyph(
alloc,
atlas,
cp,
),
else => {},
}
}
// Symbols for Legacy Computing.
cp = 0x1fb00;
while (cp <= 0x1fbef) : (cp += 1) {
@ -2932,6 +2999,32 @@ fn testRenderAll(self: Box, alloc: Allocator, atlas: *font.Atlas) !void {
else => {},
}
}
// Branch drawing character set, used for drawing git-like
// graphs in the terminal. Originally implemented in Kitty.
// Ref:
// - https://github.com/kovidgoyal/kitty/pull/7681
// - https://github.com/kovidgoyal/kitty/pull/7805
// NOTE: Kitty is GPL licensed, and its code was not referenced
// for these characters, only the loose specification of
// the character set in the pull request descriptions.
//
// TODO(qwerasd): This should be in another file, but really the
// general organization of the sprite font code
// needs to be reworked eventually.
//
//
//
//
//
cp = 0xf5d0;
while (cp <= 0xf60d) : (cp += 1) {
_ = try self.renderGlyph(
alloc,
atlas,
cp,
);
}
}
test "render all sprites" {

22
src/font/sprite/Face.zig
View File

@ -263,6 +263,21 @@ const Kind = enum {
0x1FBCE...0x1FBEF,
=> .box,
// Branch drawing character set, used for drawing git-like
// graphs in the terminal. Originally implemented in Kitty.
// Ref:
// - https://github.com/kovidgoyal/kitty/pull/7681
// - https://github.com/kovidgoyal/kitty/pull/7805
// NOTE: Kitty is GPL licensed, and its code was not referenced
// for these characters, only the loose specification of
// the character set in the pull request descriptions.
//
//
//
//
//
0xF5D0...0xF60D => .box,
// Powerline fonts
0xE0B0,
0xE0B4,
@ -276,13 +291,6 @@ const Kind = enum {
0xE0D4,
=> .powerline,
// (Git Branch)
//
//
//
//
0xF5D0...0xF60D => .box,
else => null,
};
}

BIN
src/font/sprite/testdata/Box.ppm vendored
View File

Binary file not shown.