gameaudio
bubble
declare name "bubble";
declare description "Production of a water drop bubble sound.";
declare license "MIT";
declare copyright "(c) 2017: Yann Orlarey, GRAME";
import("stdfaust.lib");
//---------------------------bubble--------------------------
// bubble(f0, trig) : produces a water drop bubble sound
//
// #### Usage
//
//
// bubble(f0, trig) : _
//
//
// Where:
//
// * f0 : base frequency of bubble sound
// * trig: trigs the bubble sound on the rising front
//
// #### Example
//
//
// button("drop") : bubble(600) : _
//
//
// #### Reference:
//
// <http://www.cs.ubc.ca/~kvdoel/publications/tap05.pdf>
//------------------------------------------------------------
bubble(f0,trig) = os.osc(f) * (exp(-damp*time) : si.smooth(0.99))
with {
damp = 0.043*f0 + 0.0014*f0^(3/2);
f = f0*(1+sigma*time);
sigma = eta * damp;
eta = 0.075;
time = 0 : (select2(trig>trig'):+(1)) ~ _ : ba.samp2sec;
};
process = button("drop") : bubble(hslider("v:bubble/freq", 600, 150, 2000, 1)) <: dm.freeverb_demo;
fire
import("stdfaust.lib");
//----------------------------fire---------------------------
// fire(is_wet) : produces burning fire sound
//
// #### Usage
//
//
// fire(is_wet) : _
//
//
// Where:
//
// * is_wet: a binary flag/signal adding wet wood
// popping sound
//
// #### Example
//
//
// checkbox("wet") : fire : _
//
//
//------------------------------------------------------------
sq(x) = x * x;
stretch(ms) = ba.countdown(ma.SR * ms / 1000): >(0);
crackle(dens, rel) = ((no.noise : fi.lowpass(3, 10000)) * 0.77 * os.osc(50 / dens) *
en.arfe(0.001, release, 0, trigger: >(0)
: stretch(sus)))
: fi.highpass(3, 1000)
with {
trigger = no.sparse_noise(dens): abs;
sus = 2 + (trigger: ba.latch(trigger) * 8);
release = rel + (0.3 * (no.noise : abs : ba.latch(trigger)));
};
fire(is_wet) = (is_wet * wet) + (base <: (_, fi.lowpass(3, 1000), fi.highpass(3, 10000)) :> _)
with {
hiss = (no.noise : fi.lowpass(3, 500)) / 5;
hiss2 = 0.8 * (no.noise : fi.highpass(3, 3000) / 8) * sq(no.lfnoise(1000));
wet = (3 * crackle(0.1, 0.05)) + (2 * crackle(0.2, 0.3));
base = hiss + hiss2 + (0.2 * crackle(5, 0.1));
};
process = checkbox("wet"): fire;
insects
import("stdfaust.lib");
//---------------------------cricket-------------------------
// cricket(f1, f2, trig) : produces a cricket chirp,
// the cricket sound based on examples
// from the book "Designing Sound"
// by Andy Farnell
//
// #### Usage
//
//
// cricket(f1, f2, trig) : _
//
//
// Where:
//
// * f1 : frequency of the first harmonic of the chirp
// * f2 : frequency of the second harmonic of the chirp
// * trig: the trigger impulse
//
// #### Examples
//
//
// ba.pulse(20000) : cricket(5134, 12342) : _
//
// or
//
// button("chirp") : ba.impulsify : cricket(5134, 12342, trig1) : _
//
//
//------------------------------------------------------------
//--------------------------critters------------------------
// critters(freqs) : produces background 'critters' sound,
// based on examples
// from the book "Designing Sound"
// by Andy Farnell
//
// #### Usage
//
//
// critters(freqs) : _
//
//
// Where:
//
// * freqs: a list with 4 frequencies
//
// #### Examples
//
//
// critters((2012, 4, 20, 2)) : _
//
//
//------------------------------------------------------------
//----------------------------frog--------------------------
// frog(l, f, trig) : produces a frog croaking sound,
// based on examples
// from the book "Designing Sound"
// by Andy Farnell
//
// #### Usage
//
//
// frog(l, f, trig) : _
//
//
// Where:
//
// * l : length of the croak in [ms]
// * f : the frequency of resonance (don't go below ~300Hz)
// * trig: the trigger impulse
//
// #### Examples
//
//
// button("croak") : ba.impulsify : frog(250, 900) : _
//
//
//------------------------------------------------------------
wrap(s) = s - int(s);
normsin(s) = sin(2 * ma.PI * s);
normcos(s) = cos(2 * ma.PI * s);
phasor(f) = os.phasor(1, f);
stretch(ms) = ba.countdown(ma.SR * ms / 1000) : >(0);
pulsetrain(ms, n, trig) = (trig: stretch(ms * n)) * ba.pulse(ma.SR * ms / 1000);
cricket(f1, f2, trig) = s1 : *(44) <: ((aa.clip(0, 1.0): wrap), (aa.clip(1.0, 4.0) : wrap)) :> (+):
normsin : aa.clip(0.0, 1.0) : *(s2) : *(0.3): *(e)
with {
f = 0.8;
sig = phasor(f);
phase = sig : ba.sAndH(trig);
s1 = wrap(sig + (1 - phase));
s2 = os.osc(f1) + os.osc(f2) : *(no.lfnoise(500));
e = trig : stretch(1000 / f);
};
water = no.noise : abs : ba.sAndH(no.sparse_noise(250) : abs : >(0)) :
*(1200) : +(400) : os.osc : fi.resonhp(850, 15, 1) : *(0.008);
hum = no.noise : fi.resonlp(800, 1, 0.08);
critters(freqs) = freqs : prod(i, ba.count(freqs), phasor: normcos):>
fi.resonhp(20, 1, 1) : *(os.osc(0.01)): *(0.025);
frog(l, f, trig) = out
with {
sq(x) = x * x;
src = en.asr(0.0, 1.0, l / 1000, trig);
ch1 = 1.0 / (src : max(0.5): *(-1.0): +(ch2): *(3): sq: *(2): -(1) : wrap *(122): sq: +(1));
ch2 = src : min(0.5);
ch3 = (1 - src) <: ((max(0.9) : *(-1)), min(0.5)) :> *(3) <: ((*(40): +(f)), (*(90): +(2 * f)), (*(240): +(3 * f)));
out = ch3 : vcf(ch1, 5), vcf(ch1, 4), vcf(ch1, 3) : (*(0.45), _, *(0.45)) :> fi.resonhp(10, 1, 1): *(0.5);
vcf(s, res, f) = s : fi.resonbp(f, res, 1): fi.resonlp(1400, 1, 1);
};
process = insects, background : ro.interleave(2, 2) : par(i, 2, sum(j, 2, _))
with {
N = ba.count(channels);
trig_data = ((0.1, 500, 5), (0.15, 300, 3),
(0.05, 250, 6), (0.0921, 320, 4),
(0.093, 250, 3), (0.09, 300, 2), (0.087, 150, 5));
channels = (cricket(5134, 12342),
cricket(3134, 8342),
cricket(8134, 15342),
cricket(6134, 1842),
frog(250, 900),
frog(400, 600),
frog(200, 800));
spat(rng1, rng2, trig) = sp.spat(2, r, d)
with {
r = rng1 : abs : ba.sAndH(trig);
d = rng2 : abs : ba.sAndH(trig);
};
trig(f, ms, n) = no.sparse_noise(f) : abs : >(0) <: (_, pulsetrain(ms, n));
trigsm = trig_data : par(i, N, trig): ro.interleave(2, N);
btrigs = trigsm : (si.bus(N), si.block(N));
trigs = trigsm : (si.block(N), si.bus(N));
spats = (no.multinoise(2 * N), btrigs, (trigs : channels)) : ro.interleave(N, 4): par(i, N, spat);
insects = spats : ro.interleave(2, N) : par(i, 2, sum(j, N, _));
background = water + hum +
critters((2012, 4, 20, 2)) +
critters((2134, 4.279, 20.4, 15.5)) : *(0.4) <: (_, _);
};
rain
//----------------------rain--------------------------
// A very simple rain simulator
//
// #### Usage
//
//
// rain(d,l) : _,_
//
//
// Where:
//
// * d: is the density of the rain: between 0 and 1
// * l: is the level (volume) of the rain: between 0 and 1
//
//----------------------------------------------------------
import("stdfaust.lib");
rain(density,level) = no.multinoise(2) : par(i, 2, drop) : par(i, 2, *(level))
with {
drop = _ <: @(1), (abs < density) : *;
};
process = rain(
hslider("v:rain/density", 300, 0, 1000, 1) / 1000,
hslider("v:rain/volume", 0.5, 0, 1, 0.01)
);
wind
//----------------------wind--------------------------
// A very simple wind simulator, based on a filtered white noise
//
// #### Usage
//
//
// wind(f) : _
//
//
// Where:
//
// * f: is the force of the wind: between 0 and 1
//
//----------------------------------------------------------
import("stdfaust.lib");
wind(force) = no.multinoise(2) : par(i, 2, ve.moog_vcf_2bn(force,freq)) : par(i, 2, *(force))
with {
freq = (force*87)+1 : ba.pianokey2hz;
};
process = wind(hslider("v:wind/force",0.66,0,1,0.01) : si.smooth(0.997));