diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-16 21:28:20 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-16 21:28:20 -0300 |
| commit | 6933f99ddb2d7103515d26838496309a807bba26 (patch) | |
| tree | 991c2fe7d4a57957222876e190fa4d16a0fb889c /examples/noc/src/lsystem.zig | |
| parent | 82fca5c9f29124f37f6dcd08e73e6999ce44a69d (diff) | |
| download | sketchbook-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.zig | 102 |
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}); +} |
