summaryrefslogtreecommitdiff
path: root/examples/spheres/shaders/voices.glsl
blob: c2fd56c420b900b81da64baa8286b5f161c01411 (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
94
95
96
97
98
99
100
101
// From motion to sound, shared by sim.comp (what sounds) and lookahead.comp
// (what would): each body a voice whose pitch follows its speed, whose
// modulator ratio follows how lopsided its two distances are, and whose
// depth follows how near its nearest neighbour is; and the closest pair one
// FM voice, the faster body silent, modulating the other.

struct Mapping {
    float base;
    float speed_ref;
    float depth_scale;
    float couple_scale;
    // Match layouts.Scale: free, pentatonic, diatonic, chromatic.
    uint scale;
};

// The nearest note of the scale, as a MIDI number: A minor pentatonic (A C
// D E G), A minor / C major (the white keys), every semitone, or none.
float snap(float midi, uint scale) {
    if (scale == 0u) return midi;
    if (scale == 3u) return round(midi);
    float m = midi - 69.0;
    float octave = floor(m / 12.0);
    float degree = m - 12.0 * octave;
    const float pentatonic[6] = float[](0.0, 3.0, 5.0, 7.0, 10.0, 12.0);
    const float diatonic[8] = float[](0.0, 2.0, 3.0, 5.0, 7.0, 8.0, 10.0, 12.0);
    float best = 0.0;
    if (scale == 1u) {
        for (int i = 1; i < 6; i++) if (abs(pentatonic[i] - degree) < abs(best - degree)) best = pentatonic[i];
    } else {
        for (int i = 1; i < 8; i++) if (abs(diatonic[i] - degree) < abs(best - degree)) best = diatonic[i];
    }
    return 69.0 + 12.0 * octave + best;
}

// Voices: (carrier Hz, ratio, depth, amplitude). Coupling rows: xyz the FM
// index each voice gets from each other, w whether it is the silent
// modulator.
void sing(vec2 p[3], vec2 v[3], Mapping map, out vec4 voices[3], out vec4 coupling[3]) {
    for (int i = 0; i < 3; i++) {
        float speed = length(v[i]);
        float octaves = clamp(log2(max(speed, 1e-4) / map.speed_ref), -2.0, 2.5);
        float midi = 12.0 * log2(map.base / 440.0) + 69.0 + 12.0 * octaves;
        midi = snap(midi, map.scale);
        float d1 = distance(p[i], p[(i + 1) % 3]);
        float d2 = distance(p[i], p[(i + 2) % 3]);
        float near = min(d1, d2);
        float far = max(d1, d2);
        voices[i] = vec4(
            440.0 * exp2((midi - 69.0) / 12.0),
            0.5 + 4.0 * near / max(near + far, 1e-6),
            clamp(map.depth_scale / max(near, 1e-3), 0.0, 12.0),
            0.2 + 0.15 * clamp(speed / (2.0 * map.speed_ref), 0.0, 1.0));
        coupling[i] = vec4(0.0);
    }
    int first = 0;
    int second = 1;
    float closest = distance(p[0], p[1]);
    if (distance(p[0], p[2]) < closest) { first = 0; second = 2; closest = distance(p[0], p[2]); }
    if (distance(p[1], p[2]) < closest) { first = 1; second = 2; closest = distance(p[1], p[2]); }
    int modulator = length(v[first]) > length(v[second]) ? first : second;
    int carrier = modulator == first ? second : first;
    coupling[carrier][modulator] = clamp(map.couple_scale / max(closest, 1e-3), 0.0, 4.0);
    coupling[modulator].w = 1.0;
}

// The chord with its voicing, packed: bits 0-11 the pitch classes (the
// chord), bit 12 set if it is playable, bits 16-19 the lowest note's pitch
// class (for root position), bits 24-31 how bad it sounds, 0 to 255.
// Playable: every note from E2 to A5, an octave and a fifth at most from
// lowest to highest, and the FM pair's index at most 3; past those, the
// same pitch classes are another sound, shrill, sprawling or a cloud of
// sidebands. Within them, wider, higher and harder modulated cost more.
uint voicing(vec4 voices[3], vec4 coupling[3]) {
    int low = 1000;
    int high = -1000;
    int lowest_class = 0;
    for (int i = 0; i < 3; i++) {
        int midi = int(round(69.0 + 12.0 * log2(voices[i].x / 440.0)));
        if (midi < low) {
            low = midi;
            lowest_class = ((midi % 12) + 12) % 12;
        }
        high = max(high, midi);
    }
    float index = 0.0;
    for (int i = 0; i < 3; i++) index = max(index, max(coupling[i].x, max(coupling[i].y, coupling[i].z)));
    int spread = high - low;
    bool playable = low >= 40 && high <= 81 && spread <= 19 && index <= 3.0;
    float bad = 6.0 * float(max(spread - 12, 0)) + 10.0 * float(max(high - 76, 0)) + 15.0 * index;
    return (playable ? 1u << 12 : 0u) | (uint(lowest_class) << 16) | (uint(clamp(bad, 0.0, 255.0)) << 24);
}

// The pitch classes the three voices sing, as bits (C is bit 0): the chord.
uint chordOf(vec4 voices[3]) {
    uint mask = 0u;
    for (int i = 0; i < 3; i++) {
        int midi = int(round(69.0 + 12.0 * log2(voices[i].x / 440.0)));
        mask |= 1u << uint(((midi % 12) + 12) % 12);
    }
    return mask;
}