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
|
//! Nature of Code, Example 5.4: Flow Field Following. Space toggles the
//! field's arrows; a click makes a new field.
const std = @import("std");
const sk = @import("sketch");
const vec = sk.math;
pub const name = "flow_field";
pub const width = 640;
pub const height = 360;
const resolution = 20;
const cols = width / resolution;
const rows = height / resolution;
/// The field is a function of its seed, so State keeps only the seed:
/// Processing's `noiseSeed(random(10000))`.
const FlowField = struct {
seed: u32 = 0,
fn init(rng: std.Random) FlowField {
return .{ .seed = rng.uintLessThan(u32, 10000) };
}
/// The arrow in column `i`, row `j`.
fn at(ff: FlowField, i: usize, j: usize) vec.Vec {
const xoff: f32 = @floatFromInt(i);
const yoff: f32 = @floatFromInt(j);
return vec.unit(std.math.lerp(0, std.math.tau, vec.noise(ff.seed, xoff * 0.1, yoff * 0.1, 0)));
}
fn lookup(ff: FlowField, position: vec.Vec) vec.Vec {
const column: usize = @intFromFloat(std.math.clamp(@floor(position[0] / resolution), 0, cols - 1));
const row: usize = @intFromFloat(std.math.clamp(@floor(position[1] / resolution), 0, rows - 1));
return ff.at(column, row);
}
};
const Vehicle = struct {
position: vec.Vec,
velocity: vec.Vec = .{ 0, 0 },
maxspeed: f32,
maxforce: f32,
const r = 4;
fn follow(v: *Vehicle, flow: FlowField) void {
const desired = vec.scale(flow.lookup(v.position), v.maxspeed);
const steer = vec.clampLength(desired - v.velocity, v.maxforce);
// applyForce + update: acceleration lasts one step, so it is not State.
v.velocity = vec.clampLength(v.velocity + steer, v.maxspeed);
v.position += v.velocity;
}
fn borders(v: *Vehicle) void {
const p = &v.position;
if (p[0] < -r) p[0] = width + r;
if (p[1] < -r) p[1] = height + r;
if (p[0] > width + r) p[0] = -r;
if (p[1] > height + r) p[1] = -r;
}
};
pub const State = struct {
rng: std.Random.Xoshiro256 = .init(5),
debug: bool = true,
flowfield: FlowField = .{},
vehicles: [120]Vehicle = undefined,
clock: sk.Clock = .{},
};
/// setup(): defaults cannot call the PRNG, so the random parts happen here.
pub fn init(s: *State) void {
const rng = s.rng.random();
const lerp = std.math.lerp;
s.flowfield = .init(rng);
for (&s.vehicles) |*v| v.* = .{
.position = .{ lerp(0, width, rng.float(f32)), lerp(0, height, rng.float(f32)) },
.maxspeed = lerp(2, 5, rng.float(f32)),
.maxforce = lerp(0.1, 0.5, rng.float(f32)),
};
}
pub fn update(s: *State, in: *const sk.Input) void {
if (in.pressed(sk.Key.space)) s.debug = !s.debug;
for (in.events) |e| if (e.kind == .mouse_down) {
s.flowfield = .init(s.rng.random());
};
for (0..s.clock.steps(in)) |_| for (&s.vehicles) |*v| {
v.follow(s.flowfield);
v.borders();
};
}
const arrow: sk.draw.Pen = .{ .stroke = .black, .width = 1 };
const body: sk.draw.Pen = .{ .fill = .gray(127), .stroke = .black, .width = 2 };
const triangle = [_]vec.Vec{ .{ Vehicle.r * 2, 0 }, .{ -Vehicle.r * 2, -Vehicle.r }, .{ -Vehicle.r * 2, Vehicle.r } };
pub fn draw(s: *const State, f: *sk.Frame) void {
f.clear(sk.Color.white);
if (s.debug) for (0..cols) |i| for (0..rows) |j| {
const centre = vec.scale(.{ @floatFromInt(i), @floatFromInt(j) }, resolution) + vec.splat(resolution / 2);
sk.draw.line(f, centre, centre + vec.scale(s.flowfield.at(i, j), resolution / 2), arrow);
};
for (&s.vehicles) |*v| sk.draw.polygon(f, &triangle, body.transformed(.place(v.position, vec.angle(v.velocity))));
}
|