128 lines
4.2 KiB
Zig
128 lines
4.2 KiB
Zig
const std = @import("std");
|
|
const freetype = @import("freetype");
|
|
|
|
// Remove once the stage2 compiler fixes pkg std not found
|
|
comptime {
|
|
_ = @import("utils");
|
|
}
|
|
|
|
const OutlinePrinter = struct {
|
|
library: freetype.Library,
|
|
face: freetype.Face,
|
|
output_file: std.fs.File,
|
|
path_stream: std.io.FixedBufferStream([]u8),
|
|
|
|
xMin: isize,
|
|
yMin: isize,
|
|
width: isize,
|
|
height: isize,
|
|
|
|
const Self = @This();
|
|
|
|
var buf = [_]u8{0} ** (1024 * 10);
|
|
pub fn init(file: std.fs.File) freetype.Error!Self {
|
|
var lib = try freetype.Library.init();
|
|
return Self{
|
|
.library = lib,
|
|
.face = try lib.createFace("upstream/assets/FiraSans-Regular.ttf", 0),
|
|
.output_file = file,
|
|
.path_stream = std.io.fixedBufferStream(&buf),
|
|
.xMin = 0,
|
|
.yMin = 0,
|
|
.width = 0,
|
|
.height = 0,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: Self) void {
|
|
self.library.deinit();
|
|
}
|
|
|
|
pub fn outlineExists(self: Self) bool {
|
|
const outline = self.face.glyph().outline() orelse return false;
|
|
if (outline.numContours() <= 0 or outline.numPoints() <= 0)
|
|
return false;
|
|
outline.check() catch return false;
|
|
return true;
|
|
}
|
|
|
|
pub fn flipOutline(self: Self) void {
|
|
const multiplier = 65536;
|
|
const matrix = freetype.Matrix{
|
|
.xx = 1 * multiplier,
|
|
.xy = 0 * multiplier,
|
|
.yx = 0 * multiplier,
|
|
.yy = -1 * multiplier,
|
|
};
|
|
self.face.glyph().outline().?.transform(matrix);
|
|
}
|
|
|
|
pub fn extractOutline(self: *Self) !void {
|
|
try self.path_stream.writer().writeAll("<path d='");
|
|
var callbacks = freetype.Outline.Funcs(*Self){
|
|
.move_to = moveToFunction,
|
|
.line_to = lineToFunction,
|
|
.conic_to = conicToFunction,
|
|
.cubic_to = cubicToFunction,
|
|
.shift = 0,
|
|
.delta = 0,
|
|
};
|
|
try self.face.glyph().outline().?.decompose(self, callbacks);
|
|
try self.path_stream.writer().writeAll("' fill='#000'/>");
|
|
}
|
|
|
|
pub fn computeViewBox(self: *Self) !void {
|
|
const boundingBox = try self.face.glyph().outline().?.bbox();
|
|
self.xMin = boundingBox.xMin;
|
|
self.yMin = boundingBox.yMin;
|
|
self.width = boundingBox.xMax - boundingBox.xMin;
|
|
self.height = boundingBox.yMax - boundingBox.yMin;
|
|
}
|
|
|
|
pub fn printSVG(self: Self) !void {
|
|
try self.output_file.writer().print(
|
|
\\<svg xmlns='http://www.w3.org/2000/svg'
|
|
\\ xmlns:xlink='http://www.w3.org/1999/xlink'
|
|
\\ viewBox='{d} {d} {d} {d}'>
|
|
\\ {s}
|
|
\\</svg>
|
|
, .{ self.xMin, self.yMin, self.width, self.height, self.path_stream.getWritten() });
|
|
}
|
|
|
|
pub fn moveToFunction(self: *Self, to: freetype.Vector) freetype.Error!void {
|
|
self.path_stream.writer().print("M {d} {d}\t", .{ to.x, to.y }) catch unreachable;
|
|
}
|
|
|
|
pub fn lineToFunction(self: *Self, to: freetype.Vector) freetype.Error!void {
|
|
self.path_stream.writer().print("L {d} {d}\t", .{ to.x, to.y }) catch unreachable;
|
|
}
|
|
|
|
pub fn conicToFunction(self: *Self, control: freetype.Vector, to: freetype.Vector) freetype.Error!void {
|
|
self.path_stream.writer().print("Q {d} {d}, {d} {d}\t", .{ control.x, control.y, to.x, to.y }) catch unreachable;
|
|
}
|
|
|
|
pub fn cubicToFunction(self: *Self, control_0: freetype.Vector, control_1: freetype.Vector, to: freetype.Vector) freetype.Error!void {
|
|
self.path_stream.writer().print("C {d} {d}, {d} {d}, {d} {d}\t", .{ control_0.x, control_0.y, control_1.x, control_1.y, to.x, to.y }) catch unreachable;
|
|
}
|
|
|
|
pub fn run(self: *Self, symbol: u32) !void {
|
|
try self.face.loadChar(symbol, .{ .no_scale = true, .no_bitmap = true });
|
|
|
|
if (!self.outlineExists())
|
|
return error.OutlineDoesntExists;
|
|
|
|
self.flipOutline();
|
|
try self.extractOutline();
|
|
try self.computeViewBox();
|
|
try self.printSVG();
|
|
}
|
|
};
|
|
|
|
pub fn main() !void {
|
|
var file = try std.fs.cwd().createFile("out.svg", .{});
|
|
defer file.close();
|
|
|
|
var outline_printer = try OutlinePrinter.init(file);
|
|
defer outline_printer.deinit();
|
|
try outline_printer.run(@as(u32, 'ë'));
|
|
}
|