summaryrefslogtreecommitdiff
path: root/examples/noc/src/processing_noise.zig
blob: e5606e698361e345236e39913311d012017d5992 (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
//! Processing's own `noise()` (PApplet.noise), for ports that must match the
//! book's pictures: its 4096-entry table filled by java.util.Random seeded
//! with `seed`, as `noiseSeed(0)` would, and its half-degree cosine fade.
//! Four octaves, falloff 0.5, like Processing's defaults. Otherwise prefer
//! `sk.math.noise` (table-free, any seed, same on every host).
const std = @import("std");

const seed: u64 = 0;
const perlin_size = 4095;
const perlin: [perlin_size + 1]f32 = blk: {
    @setEvalBranchQuota(100_000);
    const mask: u64 = (1 << 48) - 1;
    var s: u64 = (seed ^ 0x5DEECE66D) & mask;
    var table: [perlin_size + 1]f32 = undefined;
    for (&table) |*v| {
        s = (s *% 0x5DEECE66D +% 0xB) & mask;
        v.* = @as(f32, @floatFromInt(s >> 24)) / (1 << 24);
    }
    break :blk table;
};
/// Processing's cosine fade, through its half-degree cos table.
fn fade(i: f32) f32 {
    const k: f32 = @floor(i * 360);
    return 0.5 * (1 - @cos(@mod(k, 720) * std.math.pi / 360));
}

pub fn noise(x_in: f32, y_in: f32, z_in: f32) f32 {
    const ywrapb = 4;
    const ywrap = 1 << ywrapb;
    const zwrapb = 8;
    const zwrap = 1 << zwrapb;
    const x = @abs(x_in);
    const y = @abs(y_in);
    const z = @abs(z_in);
    var xi: i32 = @intFromFloat(x);
    var yi: i32 = @intFromFloat(y);
    var zi: i32 = @intFromFloat(z);
    var xf = x - @as(f32, @floatFromInt(xi));
    var yf = y - @as(f32, @floatFromInt(yi));
    var zf = z - @as(f32, @floatFromInt(zi));
    var r: f32 = 0;
    var ampl: f32 = 0.5;
    const p = struct {
        fn at(i: i32) f32 {
            return perlin[@intCast(i & perlin_size)];
        }
    }.at;
    for (0..4) |_| {
        var of = xi + (yi << ywrapb) + (zi << zwrapb);
        const rxf = fade(xf);
        const ryf = fade(yf);
        var n1 = p(of);
        n1 += rxf * (p(of + 1) - n1);
        var n2 = p(of + ywrap);
        n2 += rxf * (p(of + ywrap + 1) - n2);
        n1 += ryf * (n2 - n1);
        of += zwrap;
        n2 = p(of);
        n2 += rxf * (p(of + 1) - n2);
        var n3 = p(of + ywrap);
        n3 += rxf * (p(of + ywrap + 1) - n3);
        n2 += ryf * (n3 - n2);
        n1 += fade(zf) * (n2 - n1);
        r += n1 * ampl;
        ampl *= 0.5;
        xi <<= 1;
        xf *= 2;
        yi <<= 1;
        yf *= 2;
        zi <<= 1;
        zf *= 2;
        if (xf >= 1) {
            xi += 1;
            xf -= 1;
        }
        if (yf >= 1) {
            yi += 1;
            yf -= 1;
        }
        if (zf >= 1) {
            zi += 1;
            zf -= 1;
        }
    }
    return r;
}