summaryrefslogtreecommitdiff
path: root/examples/live/shaders/vm.glsl
blob: 06319ece61cb7519b02857cd223ec88d20af40ff (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
87
88
89
90
91
92
93
// The interpreter of Lang.zig's tapes, included by picture.frag (a pixel)
// and synth.comp (a sample), which define TAPE(i), instruction i as a uvec4
// (op, a, b, c). Instruction i writes register r[i] from earlier registers
// a, b and c; a constant's a is its value's bits, seq's b and c a first
// register and a count. Every thread runs the same instructions, so the
// switch never diverges. The registers are a local array (in the GPU's
// local memory): an array of 16 kept in registers measured twice as slow,
// its indexing turned into selects (the probe, in the package's README).
#include "ops.glsl"

const uint MAX_TAPE = 128u;

// An integer hash (no tables), to -1..1.
float lattice(vec3 p) {
    uvec3 q = uvec3(ivec3(p));
    uint h = (q.x * 0x8da6b343u) ^ (q.y * 0xd8163841u) ^ (q.z * 0xcb1ab31fu);
    h ^= h >> 16;
    h *= 0x7feb352du;
    h ^= h >> 15;
    h *= 0x846ca68bu;
    h ^= h >> 16;
    return float(h) * (2.0 / 4294967295.0) - 1.0;
}

// Value noise, smooth, -1..1.
float noise(vec3 p) {
    vec3 i = floor(p);
    vec3 f = p - i;
    vec3 w = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
    return mix(
        mix(mix(lattice(i), lattice(i + vec3(1, 0, 0)), w.x), mix(lattice(i + vec3(0, 1, 0)), lattice(i + vec3(1, 1, 0)), w.x), w.y),
        mix(mix(lattice(i + vec3(0, 0, 1)), lattice(i + vec3(1, 0, 1)), w.x), mix(lattice(i + vec3(0, 1, 1)), lattice(i + vec3(1, 1, 1)), w.x), w.y),
        w.z);
}

vec3 hsv(float h, float s, float v) {
    vec3 k = clamp(abs(fract(h + vec3(1.0, 2.0 / 3.0, 1.0 / 3.0)) * 6.0 - 3.0) - 1.0, 0.0, 1.0);
    return v * mix(vec3(1.0), k, s);
}

// The tape at TAPE(base) .. TAPE(base + len - 1) at one point: a colour if
// it ends in one, else its last register, grey.
vec3 vm(uint base, uint len, float t, float x, float y) {
    float r[MAX_TAPE];
    vec3 color = vec3(0.0);
    for (uint i = 0u; i < len; i++) {
        uvec4 k = TAPE(base + i);
        float a = r[k.y & 127u];
        float b = r[k.z & 127u];
        float c = r[k.w & 127u];
        float v = 0.0;
        switch (k.x) {
        case OP_constant: v = uintBitsToFloat(k.y); break;
        case OP_t: v = t; break;
        case OP_x: v = x; break;
        case OP_y: v = y; break;
        case OP_add: v = a + b; break;
        case OP_sub: v = a - b; break;
        case OP_mul: v = a * b; break;
        case OP_div: v = a / b; break;
        case OP_neg: v = -a; break;
        case OP_copy: v = a; break;
        case OP_seq: v = r[(k.z + uint(mod(floor(a), float(k.w)))) & 127u]; break;
        case OP_sin: v = sin(a); break;
        case OP_cos: v = cos(a); break;
        case OP_exp: v = exp(a); break;
        case OP_log: v = log(a); break;
        case OP_pow: v = pow(a, b); break;
        case OP_sqrt: v = sqrt(a); break;
        case OP_abs: v = abs(a); break;
        case OP_floor: v = floor(a); break;
        case OP_fract: v = fract(a); break;
        case OP_min: v = min(a, b); break;
        case OP_max: v = max(a, b); break;
        case OP_clamp: v = clamp(a, b, c); break;
        case OP_mix: v = mix(a, b, c); break;
        case OP_step: v = step(a, b); break;
        // GLSL leaves smoothstep undefined for lo > hi; this one is not.
        case OP_smoothstep: v = clamp((c - a) / (b - a), 0.0, 1.0); v = v * v * (3.0 - 2.0 * v); break;
        case OP_atan2: v = atan(a, b); break;
        case OP_noise: v = noise(vec3(a, b, c)); break;
        case OP_saw: v = 2.0 * fract(a + 0.5) - 1.0; break;
        case OP_sqr: v = fract(a) < 0.5 ? 1.0 : -1.0; break;
        case OP_tri: v = 4.0 * abs(fract(a - 0.25) - 0.5) - 1.0; break;
        case OP_hsv: color = hsv(a, b, c); break;
        case OP_rgb: color = vec3(a, b, c); break;
        }
        r[i] = v;
    }
    if (len == 0u) return vec3(0.0);
    uint last = TAPE(base + len - 1u).x;
    return last == OP_hsv || last == OP_rgb ? color : vec3(r[len - 1u]);
}