## The building blocks every Tidewall sound is made from: seeded noise, wavetable ## oscillators, filters, envelopes, decaying modes and a mixer. Buffers are mono ## PackedFloat32Array at RATE samples a second. Everything here is a pure function of ## its arguments and the seed it is given, so the same engine build renders the same ## bytes every time (see tools/audio/generate.gd and test_audio_assets). ## ## No samples, recordings or third-party audio go in: every sound starts from these ## functions. extends RefCounted const RATE: int = 22050 const TABLE_SIZE: int = 2048 static var _tables: Dictionary = {} ## Seconds to samples. static func n(seconds: float) -> int: return maxi(1, int(round(seconds * RATE))) static func silence(seconds: float) -> PackedFloat32Array: var out: PackedFloat32Array = PackedFloat32Array() out.resize(n(seconds)) out.fill(0.0) return out ## White noise from a seeded generator. static func noise(seconds: float, seed_value: int) -> PackedFloat32Array: var rng: RandomNumberGenerator = RandomNumberGenerator.new() rng.seed = seed_value var out: PackedFloat32Array = PackedFloat32Array() out.resize(n(seconds)) for i: int in out.size(): out[i] = rng.randf() * 2.0 - 1.0 return out ## Brown-ish noise: white noise through a leaky integrator, for surf and rumble. static func brown(seconds: float, seed_value: int) -> PackedFloat32Array: var white: PackedFloat32Array = noise(seconds, seed_value) var level: float = 0.0 for i: int in white.size(): level = level * 0.985 + white[i] * 0.12 white[i] = level return white ## One cycle of a band-limited waveform: "sine", "saw", "square", "reed" (a narrow ## pulse, like a free reed) or "bow" (a saw with softened upper partials). static func table(shape: String) -> PackedFloat32Array: if _tables.has(shape): return _tables[shape] var out: PackedFloat32Array = PackedFloat32Array() out.resize(TABLE_SIZE) out.fill(0.0) var partials: int = 24 for k: int in range(1, partials + 1): var amp: float = 0.0 match shape: "sine": amp = 1.0 if k == 1 else 0.0 "saw": amp = 1.0 / k "square": amp = (1.0 / k) if k % 2 == 1 else 0.0 "reed": # A pulse of width 1/5: strong odd and even partials with gaps. amp = absf(sin(PI * k * 0.2)) / k "bow": amp = 1.0 / pow(k, 1.35) if amp == 0.0: continue for i: int in TABLE_SIZE: out[i] += amp * sin(TAU * k * float(i) / TABLE_SIZE) var peak: float = 0.0 for value: float in out: peak = maxf(peak, absf(value)) for i: int in TABLE_SIZE: out[i] /= peak _tables[shape] = out return out ## A wavetable oscillator. `pitch` is Hz, either a constant or a curve given as ## [start, end] gliding exponentially; `vibrato` is [rate Hz, depth in semitones]. static func osc(shape: String, seconds: float, pitch: Array, vibrato: Array = [0.0, 0.0], phase: float = 0.0) -> PackedFloat32Array: var wave: PackedFloat32Array = table(shape) var count: int = n(seconds) var out: PackedFloat32Array = PackedFloat32Array() out.resize(count) var start: float = float(pitch[0]) var finish: float = float(pitch[pitch.size() - 1]) var position: float = phase * TABLE_SIZE for i: int in count: var t: float = float(i) / count var hz: float = start * pow(finish / start, t) if vibrato[0] > 0.0: hz *= pow(2.0, vibrato[1] * sin(TAU * vibrato[0] * float(i) / RATE) / 12.0) var index: int = int(position) var frac: float = position - index var a: float = wave[index % TABLE_SIZE] var b: float = wave[(index + 1) % TABLE_SIZE] out[i] = a + (b - a) * frac position = fmod(position + hz * TABLE_SIZE / RATE, float(TABLE_SIZE)) return out ## One-pole low-pass, cutoff in Hz, either fixed or gliding [start, end]. static func lowpass(input: PackedFloat32Array, cutoff: Array, passes: int = 1) -> PackedFloat32Array: var out: PackedFloat32Array = input.duplicate() var start: float = float(cutoff[0]) var finish: float = float(cutoff[cutoff.size() - 1]) for _pass: int in passes: var state: float = 0.0 for i: int in out.size(): var hz: float = start * pow(finish / start, float(i) / out.size()) var a: float = 1.0 - exp(-TAU * hz / RATE) state += a * (out[i] - state) out[i] = state return out static func highpass(input: PackedFloat32Array, cutoff: float) -> PackedFloat32Array: var low: PackedFloat32Array = lowpass(input, [cutoff]) var out: PackedFloat32Array = input.duplicate() for i: int in out.size(): out[i] -= low[i] return out ## A resonant band-pass (RBJ biquad), centre in Hz, either fixed or gliding. static func bandpass(input: PackedFloat32Array, centre: Array, q: float) -> PackedFloat32Array: var out: PackedFloat32Array = PackedFloat32Array() out.resize(input.size()) var x1: float = 0.0 var x2: float = 0.0 var y1: float = 0.0 var y2: float = 0.0 var start: float = float(centre[0]) var finish: float = float(centre[centre.size() - 1]) for i: int in input.size(): var hz: float = start * pow(finish / start, float(i) / input.size()) var w: float = TAU * minf(hz, RATE * 0.45) / RATE var alpha: float = sin(w) / (2.0 * q) var a0: float = 1.0 + alpha var b0: float = alpha / a0 var b2: float = -alpha / a0 var a1: float = -2.0 * cos(w) / a0 var a2: float = (1.0 - alpha) / a0 var x: float = input[i] var y: float = b0 * x + b2 * x2 - a1 * y1 - a2 * y2 x2 = x1 x1 = x y2 = y1 y1 = y out[i] = y return out ## Multiplies by an exponential decay that falls 60 dB over `decay` seconds, after ## a linear attack of `attack` seconds. static func decay(input: PackedFloat32Array, attack: float, decay_seconds: float) -> PackedFloat32Array: var out: PackedFloat32Array = input.duplicate() var attack_n: int = n(attack) if attack > 0.0 else 0 var k: float = log(1000.0) / maxf(decay_seconds * RATE, 1.0) for i: int in out.size(): var gain: float = 1.0 if i < attack_n: gain = float(i) / attack_n else: gain = exp(-k * (i - attack_n)) out[i] *= gain return out ## Multiplies by a piecewise-linear envelope: points are [seconds, gain] in order. static func shape(input: PackedFloat32Array, points: Array) -> PackedFloat32Array: var out: PackedFloat32Array = input.duplicate() var p: int = 0 for i: int in out.size(): var t: float = float(i) / RATE while p < points.size() - 2 and t > float(points[p + 1][0]): p += 1 var t0: float = float(points[p][0]) var t1: float = float(points[p + 1][0]) var g0: float = float(points[p][1]) var g1: float = float(points[p + 1][1]) var u: float = clampf((t - t0) / maxf(t1 - t0, 0.00001), 0.0, 1.0) out[i] *= lerpf(g0, g1, u) return out ## Struck modes: a sum of decaying sines at `base` times each ratio, with gains and ## decays (seconds to -60 dB) per mode. Wood, bells, iron and drums. static func modes(seconds: float, base: float, ratios: Array, gains: Array, decays: Array, glide: float = 1.0) -> PackedFloat32Array: var out: PackedFloat32Array = silence(seconds) for m: int in ratios.size(): var hz: float = base * float(ratios[m]) if hz >= RATE * 0.45: continue var tone: PackedFloat32Array = decay(osc("sine", seconds, [hz, hz * glide]), 0.0008, float(decays[m])) mix_into(out, tone, 0, float(gains[m])) return out ## Adds `source` times `gain` into `target` from sample `at`. With `wrap`, what runs ## past the end comes round to the start, for seamless loops. static func mix_into(target: PackedFloat32Array, source: PackedFloat32Array, at: int, gain: float = 1.0, wrap: bool = false) -> void: var size: int = target.size() for i: int in source.size(): var j: int = at + i if j >= size: if not wrap: return j %= size if j < 0: continue target[j] += source[i] * gain static func scaled(input: PackedFloat32Array, gain: float) -> PackedFloat32Array: var out: PackedFloat32Array = input.duplicate() for i: int in out.size(): out[i] *= gain return out ## Gentle saturation, for powder bangs and heavy hits. static func saturate(input: PackedFloat32Array, drive: float) -> PackedFloat32Array: var out: PackedFloat32Array = input.duplicate() var norm: float = tanh(drive) for i: int in out.size(): out[i] = tanh(out[i] * drive) / norm return out ## Crossfades the last `seconds` of a buffer into its start and trims them, so it loops ## without a click. static func make_loop(input: PackedFloat32Array, seconds: float) -> PackedFloat32Array: var fade: int = n(seconds) var length: int = input.size() - fade var out: PackedFloat32Array = input.slice(0, length) for i: int in fade: var u: float = float(i) / fade out[i] = input[i] * sqrt(u) + input[length + i] * sqrt(1.0 - u) return out ## Echoes: copies of the buffer at `delay` seconds, each `feedback` times the last, ## low-passed a little more each time. Black-powder reports off cliffs and water. static func echo(input: PackedFloat32Array, delay_seconds: float, feedback: float, repeats: int) -> PackedFloat32Array: var step: int = n(delay_seconds) var out: PackedFloat32Array = input.duplicate() out.resize(input.size() + step * repeats) for i: int in range(input.size(), out.size()): out[i] = 0.0 var tap: PackedFloat32Array = input var gain: float = 1.0 for r: int in range(1, repeats + 1): gain *= feedback tap = lowpass(tap, [2400.0 / r]) mix_into(out, tap, step * r, gain) return out ## Concatenates buffers with `gap` seconds of silence between them. static func sequence(parts: Array, gap: float) -> PackedFloat32Array: var out: PackedFloat32Array = PackedFloat32Array() for index: int in parts.size(): out.append_array(parts[index]) if index < parts.size() - 1: out.append_array(silence(gap)) return out static func midi_hz(note: float) -> float: return 440.0 * pow(2.0, (note - 69.0) / 12.0)