summaryrefslogtreecommitdiff
path: root/examples/spheres/shaders/lookahead.comp
blob: 75902d7b93e374684d6bd28cccf21528c3d06a66 (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
#version 450
#extension GL_GOOGLE_include_directive : require
// Futures of system 0, one per thread, for spheres as an instrument: from
// the preset's start, alternative 0 exactly as system 0 began and the
// others nudged by growing amounts, so where the system is chaotic their
// futures fan out. Each is integrated ahead `count` samples a frame (with
// physics.glsl, as the live system is), leaving a snapshot every
// `sample_dt` and the chord its bodies would sing there (voices.glsl). A
// chord chosen then finds the nearest time it plays, in any of them.
layout(local_size_x = 32) in;

#include "LookParams.glsl"
#include "physics.glsl"
#include "voices.glsl"

// Where each alternative has got to: 3 vec4s each (position xy, velocity zw).
layout(set = 1, binding = 0) buffer State { vec4 state[]; };
// Snapshots, sample-major: sample t of alternative a at 3 (t * K + a).
layout(set = 1, binding = 1) buffer Snapshots { vec4 snapshots[]; };
// Chords, sample-major: t * K + a.
layout(set = 1, binding = 2) buffer Chords { uint chords[]; };

// Match main.zig's leapfrog step.
const float BASE_STEP = 0.004;

void main() {
    uint alt = gl_GlobalInvocationID.x;
    if (alt >= u.alternatives) return;
    vec3 m = u.masses.xyz;
    vec2 p[3];
    vec2 v[3];
    for (int i = 0; i < 3; i++) {
        vec4 b = state[3u * alt + uint(i)];
        p[i] = b.xy;
        v[i] = b.zw;
    }
    vec2 a[3];
    accelerations(p, m, u.softening, a);
    Mapping map = Mapping(u.base, u.speed_ref, u.depth_scale, u.couple_scale, u.quantize);
    uint steps = uint(ceil(u.sample_dt / BASE_STEP));
    float dt = u.sample_dt / float(steps);
    for (uint t = u.first; t < min(u.first + u.count, u.horizon); t++) {
        uint at = t * u.alternatives + alt;
        for (int i = 0; i < 3; i++) snapshots[3u * at + uint(i)] = vec4(p[i], v[i]);
        vec4 sung[3];
        vec4 coupled[3];
        sing(p, v, map, sung, coupled);
        chords[at] = chordOf(sung) | voicing(sung, coupled);
        for (uint k = 0u; k < steps; k++) leapfrog(p, v, a, dt, m, u.softening, 256.0);
    }
    for (int i = 0; i < 3; i++) state[3u * alt + uint(i)] = vec4(p[i], v[i]);
}