summaryrefslogtreecommitdiff
path: root/src/host/TimingAtlas.zig
blob: bde8a0a5d4ca0d5e3a187faa9f02e0b1195845eb (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
//! One immutable texture for the timing overlay's printable ASCII glyphs.
const Atlas = @This();
const std = @import("std");
const abi = @import("abi");
const gfx = @import("gfx.zig");
const c = @import("c");

image: abi.Image = .none,
advance: f32 = 0,
cell_width: f32 = 0,
cell_height: f32 = 0,

const padding = 1;
const glyphs = blk: {
    var bytes: [95]u8 = undefined;
    for (&bytes, 0..) |*byte, i| byte.* = @intCast(i + 32);
    break :blk bytes;
};

/// Called once with Painter on its canvas. Images owns the texture until shutdown.
pub fn init(images: *gfx.Images, painter: *gfx.Painter) !Atlas {
    const size = gfx.textSize(images.renderer, 1, "0", .mono);
    var atlas: Atlas = .{
        .advance = size[0],
        .cell_width = @ceil(size[0]) + padding * 2,
        .cell_height = @ceil(size[1]) + padding * 2,
    };
    atlas.image = images.new(@intFromFloat(atlas.cell_width * glyphs.len), @intFromFloat(atlas.cell_height));
    errdefer images.free(atlas.image);
    const entry = images.get(atlas.image) orelse return error.TimingAtlasCreationFailed;
    if (entry.texture == null) return error.TimingAtlasCreationFailed;
    // The atlas stores the native scale-one raster; do not supersample this cache.
    const smooth = painter.smooth;
    painter.smooth = false;
    defer painter.smooth = smooth;
    painter.draw(.{ .target = atlas.image });
    painter.draw(.{ .clear = .{ .r = 0, .g = 0, .b = 0, .a = 0 } });
    for (glyphs, 0..) |_, i| painter.draw(.{ .text = .{
        .x = @as(f32, @floatFromInt(i)) * atlas.cell_width + padding,
        .y = padding,
        .scale = 1,
        .raster = 1,
        .color = .white,
        .bytes = glyphs[i..][0..1],
    } });
    // The unused space cell also supplies an opaque texel for bars/backgrounds.
    painter.draw(.{ .rect = .{ .dst = .{ .x = 0, .y = 0, .w = 1, .h = 1 }, .color = .white } });
    painter.draw(.{ .target = .none });
    return atlas;
}

fn source(atlas: Atlas, byte: u8) abi.Rect {
    const printable = if (byte >= 32 and byte <= 126) byte else '?';
    return .{ .x = @as(f32, @floatFromInt(printable - 32)) * atlas.cell_width, .y = 0, .w = atlas.cell_width, .h = atlas.cell_height };
}

/// The complete overlay fits one fixed vertex/index batch and one SDL draw call.
pub const Batch = struct {
    const capacity = 4 * 96 + 48 + @import("Timing.zig").capacity + 2;
    atlas: Atlas,
    vertices: [capacity * 4]c.SDL_Vertex = undefined,
    indices: [capacity * 6]u16 = undefined,
    count: usize = 0,

    pub fn rect(batch: *Batch, dst: abi.Rect, color: abi.Color) !void {
        try batch.quad(dst, .{ .x = 0.5, .y = 0.5, .w = 0, .h = 0 }, color);
    }

    pub fn text(batch: *Batch, bytes: []const u8, x: f32, y: f32, scale: f32, color: abi.Color) !void {
        const atlas = batch.atlas;
        for (bytes, 0..) |byte, i| {
            if (byte == ' ') continue;
            try batch.quad(.{
                .x = x + (@as(f32, @floatFromInt(i)) * atlas.advance - padding) * scale,
                .y = y - padding * scale,
                .w = atlas.cell_width * scale,
                .h = atlas.cell_height * scale,
            }, atlas.source(byte), color);
        }
    }

    fn quad(batch: *Batch, dst: abi.Rect, src: abi.Rect, color: abi.Color) !void {
        if (batch.count == capacity) return error.TimingBatchFull;
        const width = batch.atlas.cell_width * glyphs.len;
        const height = batch.atlas.cell_height;
        const alpha = @as(f32, @floatFromInt(color.a)) / 255;
        const tint: c.SDL_FColor = .{
            .r = @as(f32, @floatFromInt(color.r)) / 255 * alpha,
            .g = @as(f32, @floatFromInt(color.g)) / 255 * alpha,
            .b = @as(f32, @floatFromInt(color.b)) / 255 * alpha,
            .a = alpha,
        };
        const base = batch.count * 4;
        const corners = [4][2]f32{ .{ 0, 0 }, .{ 1, 0 }, .{ 1, 1 }, .{ 0, 1 } };
        for (corners, 0..) |corner, i| batch.vertices[base + i] = .{
            .position = .{ .x = dst.x + corner[0] * dst.w, .y = dst.y + corner[1] * dst.h },
            .color = tint,
            .tex_coord = .{ .x = (src.x + corner[0] * src.w) / width, .y = (src.y + corner[1] * src.h) / height },
        };
        for ([_]u16{ 0, 1, 2, 0, 2, 3 }, 0..) |index, i| batch.indices[batch.count * 6 + i] = @as(u16, @intCast(base)) + index;
        batch.count += 1;
    }

    pub fn draw(batch: *const Batch, painter: *gfx.Painter) void {
        painter.texturedTriangles(batch.atlas.image, batch.vertices[0 .. batch.count * 4], batch.indices[0 .. batch.count * 6]);
    }
};

test "timing atlas ASCII cells and scaled glyph positions share one image" {
    const atlas: Atlas = .{ .image = @fromBackingInt(7), .advance = 7.5, .cell_width = 10, .cell_height = 16 };
    try std.testing.expectEqual(@as(f32, 0), atlas.source(' ').x);
    try std.testing.expectEqual(@as(f32, 940), atlas.source('~').x);
    try std.testing.expectEqual(atlas.source('?'), atlas.source(0xff));
    var batch: Batch = .{ .atlas = atlas };
    try batch.text("1 2", 10, 20, 0.5, .white);
    try std.testing.expectEqual(@as(usize, 2), batch.count);
    try std.testing.expectEqual(@as(f32, 9.5), batch.vertices[0].position.x);
    try std.testing.expectEqual(@as(f32, 19.5), batch.vertices[0].position.y);
    try std.testing.expectEqual(@as(f32, 14.5), batch.vertices[2].position.x);
    try std.testing.expectEqual(@as(f32, 27.5), batch.vertices[2].position.y);
    try std.testing.expectEqual(@as(f32, 17), batch.vertices[4].position.x);
    try std.testing.expectEqual(@as(f32, 170.0 / 950.0), batch.vertices[0].tex_coord.x);
    try std.testing.expectEqual(@as(f32, 180.0 / 950.0), batch.vertices[4].tex_coord.x);
    try std.testing.expectEqualSlices(u16, &.{ 0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7 }, batch.indices[0..12]);
}

test "timing batch is bounded and solid quads sample one opaque atlas texel" {
    var batch: Batch = .{ .atlas = .{ .image = @fromBackingInt(1), .advance = 8, .cell_width = 10, .cell_height = 16 } };
    const box: abi.Rect = .{ .x = 10, .y = 20, .w = 5, .h = 8 };
    for (0..Batch.capacity) |_| try batch.rect(box, .{ .r = 255, .g = 128, .b = 0, .a = 128 });
    try std.testing.expectError(error.TimingBatchFull, batch.rect(box, .white));
    for (batch.indices) |index| try std.testing.expect(index < batch.vertices.len);
    for (batch.vertices[0..4]) |vertex| {
        try std.testing.expectEqual(batch.vertices[0].tex_coord, vertex.tex_coord);
        try std.testing.expectApproxEqAbs(@as(f32, 128.0 / 255.0), vertex.color.r, 0.00001);
        try std.testing.expectApproxEqAbs(@as(f32, 128.0 / 255.0), vertex.color.a, 0.00001);
    }
}