summaryrefslogtreecommitdiff
path: root/examples/noc/src/lsystem.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-16 21:28:20 -0300
committerGabriel Schneider <[email protected]>2026-11-16 21:28:20 -0300
commit6933f99ddb2d7103515d26838496309a807bba26 (patch)
tree991c2fe7d4a57957222876e190fa4d16a0fb889c /examples/noc/src/lsystem.zig
parent82fca5c9f29124f37f6dcd08e73e6999ce44a69d (diff)
downloadsketchbook-6933f99ddb2d7103515d26838496309a807bba26.tar.gz
sketchbook-6933f99ddb2d7103515d26838496309a807bba26.zip
Move standalone sketches into sketchbook examples
Diffstat (limited to 'examples/noc/src/lsystem.zig')
-rw-r--r--examples/noc/src/lsystem.zig102
1 files changed, 102 insertions, 0 deletions
diff --git a/examples/noc/src/lsystem.zig b/examples/noc/src/lsystem.zig
new file mode 100644
index 0000000..b5ac660
--- /dev/null
+++ b/examples/noc/src/lsystem.zig
@@ -0,0 +1,102 @@
+//! Nature of Code, Example 8.9: an L-system, drawn by a turtle. Each click
+//! rewrites the sentence once more (after 5, back to the axiom).
+const std = @import("std");
+const sk = @import("sketch");
+const vec = sk.math;
+
+pub const name = "lsystem";
+pub const width = 640;
+pub const height = 360;
+
+const axiom = "F";
+/// The book's one rule; every other character stays itself.
+const rule = .{ 'F', "FF+[+F-F-F]-[-F+F+F]" };
+const angle = std.math.degreesToRadians(25.0);
+const max_generation = 5;
+
+/// The sentence follows from the axiom, the rule and how often it ran:
+/// State keeps only the count. The sentence itself grows eightfold a
+/// generation (11 116 characters at 4, 88 940 at 5), which is Session's
+/// business, rebuilt by `Derived` when the count changes.
+pub const State = struct {
+ generation: u8 = 4,
+};
+
+pub const Session = struct {
+ tree: sk.Derived(Tree) = .{ .value = .{} },
+};
+
+const Tree = struct {
+ sentence: std.ArrayList(u8) = .empty,
+ picture: sk.draw.Tessellation = .empty,
+};
+
+pub fn update(s: *State, in: *const sk.Input) void {
+ if (in.mousePressed(.left) != null) s.generation = if (s.generation == max_generation) 0 else s.generation + 1;
+}
+
+/// The book's `generate()`, `generation` times.
+fn rewrite(gpa: std.mem.Allocator, sentence: *std.ArrayList(u8), generation: u8) !void {
+ sentence.clearRetainingCapacity();
+ try sentence.appendSlice(gpa, axiom);
+ var next: std.ArrayList(u8) = .empty;
+ defer next.deinit(gpa);
+ for (0..generation) |_| {
+ next.clearRetainingCapacity();
+ for (sentence.items) |c| {
+ if (c == rule[0]) try next.appendSlice(gpa, rule[1]) else try next.append(gpa, c);
+ }
+ std.mem.swap(std.ArrayList(u8), sentence, &next);
+ }
+}
+
+/// The turtle: `F` draws a step and moves along it, `+`/`-` turn, `[`
+/// pushes and `]` pops. A push is a call with a copy of the transform, a
+/// pop is its return: no stack to keep.
+const Turtle = struct {
+ picture: *sk.draw.Tessellation,
+ gpa: std.mem.Allocator,
+ step: f32,
+
+ /// Walks `sentence` from `i.*` until its `]` (or the end), placed by `xf`.
+ fn walk(t: Turtle, sentence: []const u8, i: *usize, start: vec.Affine) !void {
+ var xf = start;
+ while (i.* < sentence.len) {
+ const c = sentence[i.*];
+ i.* += 1;
+ switch (c) {
+ 'F', 'G' => {
+ try t.picture.strokeLine(t.gpa, .{ 0, 0 }, .{ 0, -t.step }, 1, xf);
+ xf = xf.mul(.translate(0, -t.step));
+ },
+ '+' => xf = xf.mul(.rotate(angle)),
+ '-' => xf = xf.mul(.rotate(-angle)),
+ '[' => try t.walk(sentence, i, xf),
+ ']' => return,
+ else => {},
+ }
+ }
+ }
+};
+
+fn build(tree: *Tree, gpa: std.mem.Allocator, generation: u8) !void {
+ try rewrite(gpa, &tree.sentence, generation);
+ tree.picture.clearRetainingCapacity();
+ // Each generation doubles the trunk (F → FF), so the step halves to
+ // keep the tree the book's size: 6 px at generation 4.
+ const turtle: Turtle = .{ .picture = &tree.picture, .gpa = gpa, .step = 96 / std.math.pow(f32, 2, @floatFromInt(generation)) };
+ var i: usize = 0;
+ try turtle.walk(tree.sentence.items, &i, .translate(width / 2, height));
+}
+
+pub fn draw(s: *const State, ss: *Session, f: *sk.Frame) void {
+ f.clear(sk.Color.white);
+ if (ss.tree.stale(s.generation, f.in)) build(&ss.tree.value, f.session, s.generation) catch {
+ ss.tree.forget();
+ f.host.log("out of session memory: tree dropped");
+ return;
+ };
+ f.shape(&ss.tree.value.picture, .black);
+ f.print(8, height - 64, 2, sk.Color.gray(100), "generation {d}", .{s.generation});
+ f.print(8, height - 36, 2, sk.Color.gray(100), "{d} characters", .{ss.tree.value.sentence.items.len});
+}