summaryrefslogtreecommitdiff
path: root/test/svgview.zig
blob: 0675c839e000a68af4f91bc122326304481ad438 (plain) (blame)
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
//! svgview: shows one SVG from a list, fitted to its own canvas size, with
//! either renderer. The differential tests drive it headless: set `index`
//! and `backend` from the console, screenshot, compare with resvg.
//!
//! The list is `$SVGVIEW_LIST` (default `svgview.txt`): one `path width
//! height` per line.
const std = @import("std");
const sk = @import("sketch");
const vector = @import("vector");

pub const name = "svgview";
pub const width = 512;
pub const height = 512;

pub const State = struct {
    index: u32 = 0,
    backend: vector.Backend = .gpu,
};

pub const Session = struct {
    gpu: ?vector.Renderer(.gpu) = null,
    cpu: ?vector.Renderer(.cpu) = null,
};

const Entry = struct { path: []const u8, w: u32, h: u32 };

fn entry(host: sk.Host, index: u32) ?Entry {
    const list = host.readFile(host.env("SVGVIEW_LIST") orelse "svgview.txt");
    var lines = std.mem.tokenizeScalar(u8, list, '\n');
    var i: u32 = 0;
    while (lines.next()) |line| : (i += 1) {
        if (i != index) continue;
        var words = std.mem.tokenizeScalar(u8, line, ' ');
        const path = words.next() orelse return null;
        const w = std.fmt.parseInt(u32, words.next() orelse return null, 10) catch return null;
        const h = std.fmt.parseInt(u32, words.next() orelse return null, 10) catch return null;
        return .{ .path = path, .w = w, .h = h };
    }
    return null;
}

pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
    const e = entry(f.host, s.index) orelse {
        f.clear(0x400000);
        f.text(8, 8, 2, "no such entry", 0xffffff);
        return;
    };
    f.canvas(e.w, e.h);
    show(s, ss, f, e) catch |err| {
        f.clear(0x400000);
        f.print(8, 8, 2, 0xffffff, "{s}: {t}", .{ e.path, err });
    };
}

fn show(s: *const State, ss: *Session, f: *sk.Frame, e: Entry) !void {
    const d = try vector.svg.parse(f.scratch, f.host.readFile(e.path));
    // As resvg -w does: scale to the width, from the top-left corner (the
    // height is rounded, so fitting both would drift by a fraction).
    const s_ = @as(f32, @floatFromInt(e.w)) / d.view.w;
    const place = vector.geom.Affine.scale(s_, s_).mul(.translate(-d.view.x, -d.view.y));
    switch (s.backend) {
        .gpu => try render(&ss.gpu, f, d, place, e),
        .cpu => try render(&ss.cpu, f, d, place, e),
    }
}

fn render(slot: anytype, f: *sk.Frame, d: vector.Drawing, place: vector.geom.Affine, e: Entry) !void {
    if (slot.*) |*r| if (r.width() != e.w or r.height() != e.h) {
        r.deinit(f.host);
        slot.* = null;
    };
    if (slot.* == null) slot.* = try .init(f.session, f.host, e.w, e.h);
    const r = &slot.*.?;
    // resvg's `--background '#808080'`.
    r.begin(f, .{ 128.0 / 255.0, 128.0 / 255.0, 128.0 / 255.0, 1 });
    try r.draw(d, place, 1);
    r.present(f, sk.Rect{ .w = @floatFromInt(e.w), .h = @floatFromInt(e.h) });
}