summaryrefslogtreecommitdiff
path: root/examples/live/src/main.zig
blob: 02a9c6d33fda85171093bf12d3ca34819edc91e7 (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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
//! live: a program typed over its own picture. Each line is `name =
//! expression` over t, x and y (src/Lang.zig); the `color` line is what is
//! seen. At every keystroke that leaves a program that parses, `update`
//! compiles it into a tape kept in State, which one interpreter on the GPU
//! (shaders/vm.glsl) runs per pixel. While a line is broken the last good
//! tape keeps playing and the problem is marked at its byte.
//!
//! State is the text, the tapes, the problem and the time, all changed by
//! `update` from recorded keys and ticks, so a replay or a seek brings back
//! the text, the tape and the picture of that moment. Session holds the
//! GPU objects.
const std = @import("std");
const sk = @import("sketch");
const gpu = sk.abi.gpu;
const Lang = @import("Lang");
const shaders = @import("shaders");

pub const name = "live";
pub const width = 1280;
pub const height = 720;

pub const State = struct {
    // ponytail: a plain buffer, typed characters appended and backspace
    // deleting the last; part 2 puts pardes's editor here.
    text: [4096]u8 = @splat(0),
    len: u32 = 0,
    /// The last program that parsed.
    out: Lang.Tape = .{},
    color: Lang.Tape = .{},
    /// What is wrong with the text, if it does not parse (`len` 0: nothing).
    problem: Lang.Problem = .{},
    /// Seconds, from recorded ticks: a replay draws the same frames.
    time: f32 = 0,
};

pub const Session = struct {
    picture: sk.Image = .none,
    size: [2]u32 = .{ 0, 0 },
};

pub fn update(s: *State, in: *const sk.Input) void {
    var edited = false;
    for (in.events) |e| switch (e.kind) {
        .tick => s.time += e.x,
        .text => {
            var utf8: [4]u8 = undefined;
            const n = std.unicode.utf8Encode(@intCast(@min(e.value, 0x10ffff)), &utf8) catch continue;
            if (s.len + n > s.text.len) continue;
            @memcpy(s.text[s.len..][0..n], utf8[0..n]);
            s.len += n;
            edited = true;
        },
        .key_down => switch (e.key()) {
            .backspace => if (s.len > 0) {
                s.len -= 1;
                while (s.len > 0 and s.text[s.len] & 0xc0 == 0x80) s.len -= 1;
                edited = true;
            },
            .@"return", .keypad_enter => if (s.len < s.text.len) {
                s.text[s.len] = '\n';
                s.len += 1;
                edited = true;
            },
            else => {},
        },
        else => {},
    };
    if (!edited) return;
    switch (Lang.compile(s.text[0..s.len])) {
        .program => |p| {
            s.out = p.out;
            s.color = p.color;
            s.problem = .{};
        },
        .problem => |p| s.problem = p,
    }
}

const picture_pipeline: gpu.Pipeline = .{
    .vertex = .{ .code = shaders.fullscreen_vert },
    .fragment = .{ .code = shaders.picture_frag, .uniform_buffers = 1 },
    .stride = 0,
    .attributes = &.{},
    .blend = .none,
};

pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
    f.clear(0x000000);
    if (!f.host.gpu()) {
        f.text(16, 16, 2, "live needs a GPU: the host has none.", 0xff8080);
        return;
    }
    // A tape past 64 instructions is drawn at half resolution: at 1280x720
    // 128 instructions took 2.7 ms of the GPU, at half 0.85 (the probe).
    const half: u32 = if (s.color.len > 64) 2 else 1;
    const size: [2]u32 = .{ width / half, height / half };
    if (!std.meta.eql(ss.size, size)) {
        if (ss.picture != .none) f.host.freeImage(ss.picture);
        ss.picture = f.host.newImage(size[0], size[1]);
        ss.size = size;
    }
    f.gpu(.{
        .label = "picture",
        .image = ss.picture,
        .width = size[0],
        .height = size[1],
        .pipelines = &.{picture_pipeline},
        .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = gpu.uniform(f.scratch, Lang.Picture{
            .tape = std.mem.bytesToValue([Lang.max_tape][4]u32, &s.color.code),
            .len = s.color.len,
            .time = s.time,
            .size = .{ @floatFromInt(size[0]), @floatFromInt(size[1]) },
        }) }},
    });
    f.image(ss.picture, .{ .x = 0, .y = 0, .w = width, .h = height }, .{});
    code(s, f);
}

const scale = 1.25;
const margin = 16;
const ink = 0xe8e8e8;
const red = 0xff5a50;

/// The text over the picture on a dark band, the caret at its end, and the
/// problem: a red mark under its byte and its words under the text.
// ponytail: one face at one size, so a column is a fixed advance; part 2
// draws the editor's text with sketchbook's new text instead.
fn code(s: *const State, f: *sk.Frame) void {
    const text = s.text[0..s.len];
    const cell = f.host.textSizeIn(.code, scale, "M");
    const lines = std.mem.count(u8, text, "\n") + 1;
    var widest: f32 = 0;
    var it = std.mem.splitScalar(u8, text, '\n');
    while (it.next()) |line| widest = @max(widest, f.host.textSizeIn(.code, scale, line)[0]);
    const problem = s.problem.len > 0;
    if (problem) widest = @max(widest, f.host.textSizeIn(.code, scale, s.problem.text())[0]);
    const band_h = @as(f32, @floatFromInt(lines + @intFromBool(problem))) * cell[1] + 2 * margin;
    f.fill(.{ .x = 0, .y = 0, .w = @max(widest, 24 * cell[0]) + 2 * margin + cell[0], .h = band_h }, sk.Color{ .r = 0, .g = 0, .b = 0, .a = 150 });

    var y: f32 = margin;
    var start: usize = 0;
    it = std.mem.splitScalar(u8, text, '\n');
    while (it.next()) |line| : (y += cell[1]) {
        f.textIn(.code, margin, y, scale, line, ink);
        const end = start + line.len;
        if (problem and s.problem.at >= start and s.problem.at <= end) {
            const x = margin + f.host.textSizeIn(.code, scale, text[start..s.problem.at])[0];
            f.fill(.{ .x = x, .y = y + cell[1] - 2, .w = cell[0], .h = 2 }, red);
        }
        // The caret, after the last byte.
        if (end == text.len) f.fill(.{ .x = margin + f.host.textSizeIn(.code, scale, line)[0], .y = y, .w = 2, .h = cell[1] }, ink);
        start = end + 1;
    }
    if (problem) f.textIn(.code, margin, y, scale, s.problem.text(), red);

    const mode = switch (f.in.mode) {
        .live => "live",
        .recording => "recording",
        .playing => "replay",
        .paused => "paused",
    };
    f.print(width - 200, height - 24, 1, ink, "{s} {d:.1} s", .{ mode, s.time });
}