summaryrefslogtreecommitdiff
path: root/test/render.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 21:34:41 -0300
committerGabriel Schneider <[email protected]>2026-11-12 13:22:02 -0300
commit2348776791e9dd17afeb12a06ba42a4a71917bcf (patch)
tree780c4b12b76c8b97a28408dd40944d65f159fdc7 /test/render.zig
parent590ba7b9b579b97e34b51ab7e3460ebc85713343 (diff)
downloadsketchbook-2348776791e9dd17afeb12a06ba42a4a71917bcf.tar.gz
sketchbook-2348776791e9dd17afeb12a06ba42a4a71917bcf.zip
sketchbook: a drawing layer on top, host fixes for replay and migration
Diffstat (limited to 'test/render.zig')
-rw-r--r--test/render.zig101
1 files changed, 101 insertions, 0 deletions
diff --git a/test/render.zig b/test/render.zig
new file mode 100644
index 0000000..597b252
--- /dev/null
+++ b/test/render.zig
@@ -0,0 +1,101 @@
+//! Phase 3's 2D features, for the native screenshot test
+//! (test/render.script) and the browser one (tools/render_web.mjs): an
+//! offscreen target with translucent content, drawn plain, with a
+//! translucent tint and turned; additive blending of shapes, a rect and
+//! an image over gray; shapes of several colours in one command; a soft
+//! image from `pixels`, tinted and turned; antialiased shape edges.
+//!
+//! The target is painted only when `in.jumped` (or when made): the bar
+//! under it grows by one step per repaint, and `hue` picks its colour, so
+//! a script can see that `set` repaints and plain frames do not.
+const std = @import("std");
+const sk = @import("sketch");
+const vec = sk.math;
+
+pub const name = "render";
+pub const width = 400;
+pub const height = 300;
+
+pub const State = struct {
+ hue: u8 = 0,
+};
+
+pub const Session = struct {
+ layer: sk.Image = .none,
+ soft: sk.Image = .none,
+ paints: u32 = 0,
+};
+
+const red: sk.Color = .{ .r = 255, .g = 0, .b = 0, .a = 128 };
+
+/// 32 x 32 white, alpha falling off from the middle, like NoC's texture.
+fn soft() [32 * 32]sk.Color {
+ @setEvalBranchQuota(100_000);
+ var px: [32 * 32]sk.Color = undefined;
+ for (0..32) |y| for (0..32) |x| {
+ const d = vec.distance(.{ @floatFromInt(x), @floatFromInt(y) }, .{ 15.5, 15.5 }) / 16;
+ px[y * 32 + x] = sk.Color.white.alphaFloat(1 - d);
+ };
+ return px;
+}
+const soft_pixels = soft();
+
+pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
+ f.clear(.white);
+ const fresh = ss.layer == .none;
+ if (fresh) {
+ ss.layer = f.host.newImage(100, 100);
+ ss.soft = f.host.newImage(32, 32);
+ f.pixels(ss.soft, 32, 32, std.mem.sliceAsBytes(&soft_pixels), .{});
+ }
+ if (fresh or f.in.jumped) {
+ ss.paints += 1;
+ f.target(ss.layer);
+ f.clear(sk.Color.black.alpha(0));
+ sk.draw.circle(f, .{ 50, 50 }, 40, .{ .fill = red });
+ f.fill(.{ .x = 10, .y = 60, .w = 50, .h = 30 }, if (s.hue == 0) sk.Color.hex(0x0000ff) else sk.Color.hex(0x00a000));
+ f.target(.none);
+ }
+ // The target three ways: as is, half transparent, turned.
+ f.image(ss.layer, .{ .x = 10, .y = 10, .w = 100, .h = 100 }, .{});
+ f.image(ss.layer, .{ .x = 120, .y = 10, .w = 100, .h = 100 }, .{ .tint = sk.Color.white.alpha(128) });
+ f.imageAt(ss.layer, .place(.{ 300, 60 }, std.math.pi / 6.0), .{});
+ f.fill(.{ .x = 10, .y = 115, .w = @as(f32, @floatFromInt(@min(ss.paints, 30))) * 10, .h = 4 }, .black);
+
+ // Additive blending over gray.
+ f.fill(.{ .x = 10, .y = 130, .w = 180, .h = 90 }, 0x404040);
+ f.blend(.add);
+ sk.draw.circle(f, .{ 60, 175 }, 35, .{ .fill = red });
+ sk.draw.circle(f, .{ 100, 175 }, 35, .{ .fill = sk.Color.hex(0x00c800) });
+ f.fill(.{ .x = 140, .y = 140, .w = 40, .h = 70 }, sk.Color.hex(0x2020ff).alpha(200));
+ f.image(ss.soft, .{ .x = 140, .y = 180, .w = 32, .h = 32 }, .{ .tint = sk.Color.hex(0xff64ff).alpha(200) });
+ f.blend(.alpha);
+
+ // Several colours in one shape: three circles and a ring (two subpaths).
+ var t: sk.draw.Tessellation = .empty;
+ var colors: std.ArrayList(sk.Color) = .empty;
+ const each = [_]struct { at: vec.Vec, color: sk.Color }{
+ .{ .at = .{ 230, 160 }, .color = sk.Color.hex(0xff0000) },
+ .{ .at = .{ 260, 160 }, .color = sk.Color.hex(0x00ff00).alpha(128) },
+ .{ .at = .{ 290, 160 }, .color = sk.Color.hex(0x0000ff).alpha(128) },
+ };
+ for (each) |e| {
+ t.fillCircle(f.scratch, e.at, 20, .identity) catch return;
+ while (colors.items.len < t.ends.items.len) colors.append(f.scratch, e.color) catch return;
+ }
+ t.strokeCircle(f.scratch, .{ 350, 160 }, 25, 8, .identity) catch return;
+ while (colors.items.len < t.ends.items.len) colors.append(f.scratch, sk.Color.hex(0x800080)) catch return;
+ f.shapeColors(&t, colors.items);
+
+ // The soft image: plain, tinted translucent, and turned 45 degrees.
+ f.fill(.{ .x = 210, .y = 200, .w = 180, .h = 90 }, 0x203040);
+ f.image(ss.soft, .{ .x = 220, .y = 220, .w = 32, .h = 32 }, .{});
+ f.image(ss.soft, .{ .x = 270, .y = 220, .w = 32, .h = 32 }, .{ .tint = sk.Color.hex(0xff64ff).alpha(128) });
+ f.imageAt(ss.soft, .place(.{ 346, 236 }, std.math.pi / 4.0), .{ .size = .{ 48, 48 } });
+
+ // Thin antialiased lines: a fan of 1 px strokes.
+ for (0..8) |i| {
+ const a = @as(f32, @floatFromInt(i)) * std.math.pi / 16.0;
+ sk.draw.line(f, .{ 30, 280 }, .{ 30 + 150 * @cos(a), 280 - 50 * @sin(a) }, .{ .stroke = .black });
+ }
+}