Files
claudeandClaude Opus 5.5 2545337204 A8: Synthesized sound effects and an adaptive score
Every sound is made by scripts in tools/audio/ and committed as a WAV in
assets/audio/ with a manifest of hashes and levels:

- dsp.gd: seeded noise, wavetable oscillators, filters, envelopes and
  struck modes. recipes.gd: 50 effects (footsteps on five surfaces,
  a report per weapon, impacts, carpentry building and breaking, the
  tide's bell, foghorn, surge and lighthouse, player, ambience, menus).
- score.gd: an original eight-bar tune and chords in D Dorian, 6/8,
  rendered as four looping layers (drone, frame drum, concertina,
  fiddle).
- loudness.gd and check.gd: per-category loudness targets, a -1 dBFS
  peak ceiling and the mix order (the tide loudest). make audio and
  make audio-check.

In the client, SoundDirector turns FX records, footsteps, building,
the tide and the player's own hurts into sounds, placed on 3D voices
at the event so gunfire and footsteps come from their direction.
MusicDirector fades the score's layers with the tide on an
AudioStreamSynchronized, full in menus. MenuSounds knocks for buttons.

Closes #48

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 14:28:34 -05:00

280 lines
9.5 KiB
GDScript

## 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)