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>
This commit is contained in:
@@ -0,0 +1,279 @@
|
||||
## 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)
|
||||
Reference in New Issue
Block a user