e1lama/stk
1
0
Fork 0
mirror of https://github.com/thestk/stk synced 2026-01-12 04:21:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
222f81c1c1289a80be5e7884bd944395cf2eeeaf
stk/src/Shakers.cpp

730 lines
27 KiB
C++
Raw Blame History

/***************************************************/
/*! \class Shakers
\brief PhISEM and PhOLIES class.
PhISEM (Physically Informed Stochastic Event Modeling) is an
algorithmic approach for simulating collisions of multiple
independent sound producing objects. This class is a meta-model
that can simulate a Maraca, Sekere, Cabasa, Bamboo Wind Chimes,
Water Drops, Tambourine, Sleighbells, and a Guiro.
PhOLIES (Physically-Oriented Library of Imitated Environmental
Sounds) is a similar approach for the synthesis of environmental
sounds. This class implements simulations of breaking sticks,
crunchy snow (or not), a wrench, sandpaper, and more.
Control Change Numbers:
- Shake Energy = 2
- System Decay = 4
- Number Of Objects = 11
- Resonance Frequency = 1
- Shake Energy = 128
- Instrument Selection = 1071
- Maraca = 0
- Cabasa = 1
- Sekere = 2
- Tambourine = 3
- Sleigh Bells = 4
- Bamboo Chimes = 5
- Sand Paper = 6
- Coke Can = 7
- Sticks = 8
- Crunch = 9
- Big Rocks = 10
- Little Rocks = 11
- Next Mug = 12
- Penny + Mug = 13
- Nickle + Mug = 14
- Dime + Mug = 15
- Quarter + Mug = 16
- Franc + Mug = 17
- Peso + Mug = 18
- Guiro = 19
- Wrench = 20
- Water Drops = 21
- Tuned Bamboo Chimes = 22
by Perry R. Cook with updates by Gary Scavone, 1995--2014.
*/
/***************************************************/
#include "Shakers.h"
#include "SKINImsg.h"
namespace stk {
// Maraca
const StkFloat MARACA_SOUND_DECAY = 0.95;
const StkFloat MARACA_SYSTEM_DECAY = 0.999;
const StkFloat MARACA_GAIN = 4.0;
const StkFloat MARACA_NUM_BEANS = 25;
const int MARACA_RESONANCES = 1;
const StkFloat MARACA_FREQUENCIES[MARACA_RESONANCES] = { 3200 };
const StkFloat MARACA_RADII[MARACA_RESONANCES] = { 0.96 };
const StkFloat MARACA_GAINS[MARACA_RESONANCES] = { 1.0 };
// Cabasa
const StkFloat CABASA_SOUND_DECAY = 0.96;
const StkFloat CABASA_SYSTEM_DECAY = 0.997;
const StkFloat CABASA_GAIN = 8.0;
const StkFloat CABASA_NUM_BEADS = 512;
const int CABASA_RESONANCES = 1;
const StkFloat CABASA_FREQUENCIES[CABASA_RESONANCES] = { 3000 };
const StkFloat CABASA_RADII[CABASA_RESONANCES] = { 0.7 };
const StkFloat CABASA_GAINS[CABASA_RESONANCES] = { 1.0 };
// Sekere
const StkFloat SEKERE_SOUND_DECAY = 0.96;
const StkFloat SEKERE_SYSTEM_DECAY = 0.999;
const StkFloat SEKERE_GAIN = 4.0;
const StkFloat SEKERE_NUM_BEANS = 64;
const int SEKERE_RESONANCES = 1;
const StkFloat SEKERE_FREQUENCIES[SEKERE_RESONANCES] = { 5500 };
const StkFloat SEKERE_RADII[SEKERE_RESONANCES] = { 0.6 };
const StkFloat SEKERE_GAINS[SEKERE_RESONANCES] = { 1.0 };
// Bamboo Wind Chimes
const StkFloat BAMBOO_SOUND_DECAY = 0.9;
const StkFloat BAMBOO_SYSTEM_DECAY = 0.9999;
const StkFloat BAMBOO_GAIN = 0.4;
const StkFloat BAMBOO_NUM_TUBES = 1.2;
const int BAMBOO_RESONANCES = 3;
const StkFloat BAMBOO_FREQUENCIES[BAMBOO_RESONANCES] = { 2800, 0.8 * 2800.0, 1.2 * 2800.0 };
const StkFloat BAMBOO_RADII[BAMBOO_RESONANCES] = { 0.995, 0.995, 0.995 };
const StkFloat BAMBOO_GAINS[BAMBOO_RESONANCES] = { 1.0, 1.0, 1.0 };
// Tambourine
const StkFloat TAMBOURINE_SOUND_DECAY = 0.95;
const StkFloat TAMBOURINE_SYSTEM_DECAY = 0.9985;
const StkFloat TAMBOURINE_GAIN = 1.0;
const StkFloat TAMBOURINE_NUM_TIMBRELS = 32;
const int TAMBOURINE_RESONANCES = 3; // Fixed shell + 2 moving cymbal resonances
const StkFloat TAMBOURINE_FREQUENCIES[TAMBOURINE_RESONANCES] = { 2300, 5600, 8100 };
const StkFloat TAMBOURINE_RADII[TAMBOURINE_RESONANCES] = { 0.96, 0.99, 0.99 };
const StkFloat TAMBOURINE_GAINS[TAMBOURINE_RESONANCES] = { 0.1, 0.8, 1.0 };
// Sleighbells
const StkFloat SLEIGH_SOUND_DECAY = 0.97;
const StkFloat SLEIGH_SYSTEM_DECAY = 0.9994;
const StkFloat SLEIGH_GAIN = 1.0;
const StkFloat SLEIGH_NUM_BELLS = 32;
const int SLEIGH_RESONANCES = 5;
const StkFloat SLEIGH_FREQUENCIES[SLEIGH_RESONANCES] = { 2500, 5300, 6500, 8300, 9800 };
const StkFloat SLEIGH_RADII[SLEIGH_RESONANCES] = { 0.99, 0.99, 0.99, 0.99, 0.99 };
const StkFloat SLEIGH_GAINS[SLEIGH_RESONANCES] = { 1.0, 1.0, 1.0, 0.5, 0.3 };
// Sandpaper
const StkFloat SANDPAPER_SOUND_DECAY = 0.999;
const StkFloat SANDPAPER_SYSTEM_DECAY = 0.999;
const StkFloat SANDPAPER_GAIN = 0.5;
const StkFloat SANDPAPER_NUM_GRAINS = 128;
const int SANDPAPER_RESONANCES = 1;
const StkFloat SANDPAPER_FREQUENCIES[SANDPAPER_RESONANCES] = { 4500 };
const StkFloat SANDPAPER_RADII[SANDPAPER_RESONANCES] = { 0.6 };
const StkFloat SANDPAPER_GAINS[SANDPAPER_RESONANCES] = { 1.0 };
// Cokecan
const StkFloat COKECAN_SOUND_DECAY = 0.97;
const StkFloat COKECAN_SYSTEM_DECAY = 0.999;
const StkFloat COKECAN_GAIN = 0.5;
const StkFloat COKECAN_NUM_PARTS = 48;
const int COKECAN_RESONANCES = 5; // Helmholtz + 4 metal resonances
const StkFloat COKECAN_FREQUENCIES[COKECAN_RESONANCES] = { 370, 1025, 1424, 2149, 3596 };
const StkFloat COKECAN_RADII[COKECAN_RESONANCES] = { 0.99, 0.992, 0.992, 0.992, 0.992 };
const StkFloat COKECAN_GAINS[COKECAN_RESONANCES] = { 1.0, 1.8, 1.8, 1.8, 1.8 };
// Tuned Bamboo Wind Chimes (Angklung)
const StkFloat ANGKLUNG_SOUND_DECAY = 0.95;
const StkFloat ANGKLUNG_SYSTEM_DECAY = 0.9999;
const StkFloat ANGKLUNG_GAIN = 0.5;
const StkFloat ANGKLUNG_NUM_TUBES = 1.2;
const int ANGKLUNG_RESONANCES = 7;
const StkFloat ANGKLUNG_FREQUENCIES[ANGKLUNG_RESONANCES] = { 1046.6, 1174.8, 1397.0, 1568, 1760, 2093.3, 2350 };
const StkFloat ANGKLUNG_RADII[ANGKLUNG_RESONANCES] = { 0.996, 0.996, 0.996, 0.996, 0.996, 0.996, 0.996 };
const StkFloat ANGKLUNG_GAINS[ANGKLUNG_RESONANCES] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
// Guiro
const StkFloat GUIRO_SOUND_DECAY = 0.95;
const StkFloat GUIRO_GAIN = 0.4;
const StkFloat GUIRO_NUM_PARTS = 128;
const int GUIRO_RESONANCES = 2;
const StkFloat GUIRO_FREQUENCIES[GUIRO_RESONANCES] = { 2500, 4000 };
const StkFloat GUIRO_RADII[GUIRO_RESONANCES] = { 0.97, 0.97 };
const StkFloat GUIRO_GAINS[GUIRO_RESONANCES] = { 1.0, 1.0 };
// Wrench
const StkFloat WRENCH_SOUND_DECAY = 0.95;
const StkFloat WRENCH_GAIN = 0.4;
const StkFloat WRENCH_NUM_PARTS = 128;
const int WRENCH_RESONANCES = 2;
const StkFloat WRENCH_FREQUENCIES[WRENCH_RESONANCES] = { 3200, 8000 };
const StkFloat WRENCH_RADII[WRENCH_RESONANCES] = { 0.99, 0.992 };
const StkFloat WRENCH_GAINS[WRENCH_RESONANCES] = { 1.0, 1.0 };
// Water Drops
const StkFloat WATER_SOUND_DECAY = 0.95;
const StkFloat WATER_SYSTEM_DECAY = 0.996;
const StkFloat WATER_GAIN = 1.0;
const StkFloat WATER_NUM_SOURCES = 10;
const int WATER_RESONANCES = 3;
const StkFloat WATER_FREQUENCIES[WATER_RESONANCES] = { 450, 600, 750 };
const StkFloat WATER_RADII[WATER_RESONANCES] = { 0.9985, 0.9985, 0.9985 };
const StkFloat WATER_GAINS[WATER_RESONANCES] = { 1.0, 1.0, 1.0 };
// PhOLIES (Physically-Oriented Library of Imitated Environmental
// Sounds), Perry Cook, 1997-8
// Stix1
const StkFloat STIX1_SOUND_DECAY = 0.96;
const StkFloat STIX1_SYSTEM_DECAY = 0.998;
const StkFloat STIX1_GAIN = 6.0;
const StkFloat STIX1_NUM_BEANS = 2;
const int STIX1_RESONANCES = 1;
const StkFloat STIX1_FREQUENCIES[STIX1_RESONANCES] = { 5500 };
const StkFloat STIX1_RADII[STIX1_RESONANCES] = { 0.6 };
const StkFloat STIX1_GAINS[STIX1_RESONANCES] = { 1.0 };
// Crunch1
const StkFloat CRUNCH1_SOUND_DECAY = 0.95;
const StkFloat CRUNCH1_SYSTEM_DECAY = 0.99806;
const StkFloat CRUNCH1_GAIN = 4.0;
const StkFloat CRUNCH1_NUM_BEADS = 7;
const int CRUNCH1_RESONANCES = 1;
const StkFloat CRUNCH1_FREQUENCIES[CRUNCH1_RESONANCES] = { 800 };
const StkFloat CRUNCH1_RADII[CRUNCH1_RESONANCES] = { 0.95 };
const StkFloat CRUNCH1_GAINS[CRUNCH1_RESONANCES] = { 1.0 };
// Nextmug + Coins
const StkFloat NEXTMUG_SOUND_DECAY = 0.97;
const StkFloat NEXTMUG_SYSTEM_DECAY = 0.9995;
const StkFloat NEXTMUG_GAIN = 0.8;
const StkFloat NEXTMUG_NUM_PARTS = 3;
const int NEXTMUG_RESONANCES = 4;
const StkFloat NEXTMUG_FREQUENCIES[NEXTMUG_RESONANCES] = { 2123, 4518, 8856, 10753 };
const StkFloat NEXTMUG_RADII[NEXTMUG_RESONANCES] = { 0.997, 0.997, 0.997, 0.997 };
const StkFloat NEXTMUG_GAINS[NEXTMUG_RESONANCES] = { 1.0, 0.8, 0.6, 0.4 };
const int COIN_RESONANCES = 3;
const StkFloat PENNY_FREQUENCIES[COIN_RESONANCES] = { 11000, 5200, 3835 };
const StkFloat PENNY_RADII[COIN_RESONANCES] = { 0.999, 0.999, 0.999 };
const StkFloat PENNY_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 };
const StkFloat NICKEL_FREQUENCIES[COIN_RESONANCES] = { 5583, 9255, 9805 };
const StkFloat NICKEL_RADII[COIN_RESONANCES] = { 0.9992, 0.9992, 0.9992 };
const StkFloat NICKEL_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 };
const StkFloat DIME_FREQUENCIES[COIN_RESONANCES] = { 4450, 4974, 9945 };
const StkFloat DIME_RADII[COIN_RESONANCES] = { 0.9993, 0.9993, 0.9993 };
const StkFloat DIME_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 };
const StkFloat QUARTER_FREQUENCIES[COIN_RESONANCES] = { 1708, 8863, 9045 };
const StkFloat QUARTER_RADII[COIN_RESONANCES] = { 0.9995, 0.9995, 0.9995 };
const StkFloat QUARTER_GAINS[COIN_RESONANCES] = { 1.0, 0.8, 0.5 };
const StkFloat FRANC_FREQUENCIES[COIN_RESONANCES] = { 5583, 11010, 1917 };
const StkFloat FRANC_RADII[COIN_RESONANCES] = { 0.9995, 0.9995, 0.9995 };
const StkFloat FRANC_GAINS[COIN_RESONANCES] = { 0.7, 0.4, 0.3 };
const StkFloat PESO_FREQUENCIES[COIN_RESONANCES] = { 7250, 8150, 10060 };
const StkFloat PESO_RADII[COIN_RESONANCES] = { 0.9996, 0.9996, 0.9996 };
const StkFloat PESO_GAINS[COIN_RESONANCES] = { 1.0, 1.2, 0.7 };
// Big Gravel
const StkFloat BIGROCKS_SOUND_DECAY = 0.98;
const StkFloat BIGROCKS_SYSTEM_DECAY = 0.9965;
const StkFloat BIGROCKS_GAIN = 4.0;
const StkFloat BIGROCKS_NUM_PARTS = 23;
const int BIGROCKS_RESONANCES = 1;
const StkFloat BIGROCKS_FREQUENCIES[BIGROCKS_RESONANCES] = { 6460 };
const StkFloat BIGROCKS_RADII[BIGROCKS_RESONANCES] = { 0.932 };
const StkFloat BIGROCKS_GAINS[BIGROCKS_RESONANCES] = { 1.0 };
// Little Gravel
const StkFloat LITTLEROCKS_SOUND_DECAY = 0.98;
const StkFloat LITTLEROCKS_SYSTEM_DECAY = 0.99586;
const StkFloat LITTLEROCKS_GAIN = 4.0;
const StkFloat LITTLEROCKS_NUM_PARTS = 1600;
const int LITTLEROCKS_RESONANCES = 1;
const StkFloat LITTLEROCKS_FREQUENCIES[LITTLEROCKS_RESONANCES] = { 9000 };
const StkFloat LITTLEROCKS_RADII[LITTLEROCKS_RESONANCES] = { 0.843 };
const StkFloat LITTLEROCKS_GAINS[LITTLEROCKS_RESONANCES] = { 1.0 };
Shakers :: Shakers( int type )
{
shakerType_ = -1;
this->setType( type );
}
void Shakers :: setType( int type )
{
if ( shakerType_ == type ) return;
varyFactor_ = 0.0;
shakerType_ = type;
if ( type == 1 ) { // Cabasa
nResonances_ = CABASA_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = CABASA_NUM_BEADS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = CABASA_RADII[i];
baseFrequencies_[i] = CABASA_FREQUENCIES[i];
filters_[i].gain = CABASA_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = CABASA_SYSTEM_DECAY;
baseGain_ = CABASA_GAIN;
soundDecay_ = CABASA_SOUND_DECAY;
decayScale_ = 0.97;
setEqualization( 1.0, -1.0, 0.0 );
}
else if ( type == 2 ) { // Sekere
nResonances_ = SEKERE_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = SEKERE_NUM_BEANS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = SEKERE_RADII[i];
baseFrequencies_[i] = SEKERE_FREQUENCIES[i];
filters_[i].gain = SEKERE_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = SEKERE_SYSTEM_DECAY;
baseGain_ = SEKERE_GAIN;
soundDecay_ = SEKERE_SOUND_DECAY;
decayScale_ = 0.94;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 3 ) { // Tambourine
nResonances_ = TAMBOURINE_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = TAMBOURINE_NUM_TIMBRELS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = TAMBOURINE_RADII[i];
baseFrequencies_[i] = TAMBOURINE_FREQUENCIES[i];
filters_[i].gain = TAMBOURINE_GAINS[i];
doVaryFrequency_[i] = true;
}
doVaryFrequency_[0] = false;
baseDecay_ = TAMBOURINE_SYSTEM_DECAY;
baseGain_ = TAMBOURINE_GAIN;
soundDecay_ = TAMBOURINE_SOUND_DECAY;
decayScale_ = 0.95;
varyFactor_ = 0.05;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 4 ) { // Sleighbells
nResonances_ = SLEIGH_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = SLEIGH_NUM_BELLS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = SLEIGH_RADII[i];
baseFrequencies_[i] = SLEIGH_FREQUENCIES[i];
filters_[i].gain = SLEIGH_GAINS[i];
doVaryFrequency_[i] = true;
}
baseDecay_ = SLEIGH_SYSTEM_DECAY;
baseGain_ = SLEIGH_GAIN;
soundDecay_ = SLEIGH_SOUND_DECAY;
decayScale_ = 0.9;
varyFactor_ = 0.03;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 5 ) { // Bamboo chimes
nResonances_ = BAMBOO_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = BAMBOO_NUM_TUBES;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = BAMBOO_RADII[i];
baseFrequencies_[i] = BAMBOO_FREQUENCIES[i];
filters_[i].gain = BAMBOO_GAINS[i];
doVaryFrequency_[i] = true;
}
baseDecay_ = BAMBOO_SYSTEM_DECAY;
baseGain_ = BAMBOO_GAIN;
soundDecay_ = BAMBOO_SOUND_DECAY;
decayScale_ = 0.7;
varyFactor_ = 0.2;
setEqualization( 1.0, 0.0, 0.0 );
}
else if ( type == 6 ) { // Sandpaper
nResonances_ = SANDPAPER_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = SANDPAPER_NUM_GRAINS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = SANDPAPER_RADII[i];
baseFrequencies_[i] = SANDPAPER_FREQUENCIES[i];
filters_[i].gain = SANDPAPER_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = SANDPAPER_SYSTEM_DECAY;
baseGain_ = SANDPAPER_GAIN;
soundDecay_ = SANDPAPER_SOUND_DECAY;
decayScale_ = 0.97;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 7 ) { // Cokecan
nResonances_ = COKECAN_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = COKECAN_NUM_PARTS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = COKECAN_RADII[i];
baseFrequencies_[i] = COKECAN_FREQUENCIES[i];
filters_[i].gain = COKECAN_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = COKECAN_SYSTEM_DECAY;
baseGain_ = COKECAN_GAIN;
soundDecay_ = COKECAN_SOUND_DECAY;
decayScale_ = 0.95;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 8 ) { // Stix1
nResonances_ = STIX1_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = STIX1_NUM_BEANS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = STIX1_RADII[i];
baseFrequencies_[i] = STIX1_FREQUENCIES[i];
filters_[i].gain = STIX1_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = STIX1_SYSTEM_DECAY;
baseGain_ = STIX1_GAIN;
soundDecay_ = STIX1_SOUND_DECAY;
decayScale_ = 0.96;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 9 ) { // Crunch1
nResonances_ = CRUNCH1_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = CRUNCH1_NUM_BEADS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = CRUNCH1_RADII[i];
baseFrequencies_[i] = CRUNCH1_FREQUENCIES[i];
filters_[i].gain = CRUNCH1_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = CRUNCH1_SYSTEM_DECAY;
baseGain_ = CRUNCH1_GAIN;
soundDecay_ = CRUNCH1_SOUND_DECAY;
decayScale_ = 0.96;
setEqualization( 1.0, -1.0, 0.0 );
}
else if ( type == 10 ) { // Big Rocks
nResonances_ = BIGROCKS_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = BIGROCKS_NUM_PARTS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = BIGROCKS_RADII[i];
baseFrequencies_[i] = BIGROCKS_FREQUENCIES[i];
filters_[i].gain = BIGROCKS_GAINS[i];
doVaryFrequency_[i] = true;
}
baseDecay_ = BIGROCKS_SYSTEM_DECAY;
baseGain_ = BIGROCKS_GAIN;
soundDecay_ = BIGROCKS_SOUND_DECAY;
decayScale_ = 0.95;
varyFactor_ = 0.11;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 11 ) { // Little Rocks
nResonances_ = LITTLEROCKS_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = LITTLEROCKS_NUM_PARTS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = LITTLEROCKS_RADII[i];
baseFrequencies_[i] = LITTLEROCKS_FREQUENCIES[i];
filters_[i].gain = LITTLEROCKS_GAINS[i];
doVaryFrequency_[i] = true;
}
baseDecay_ = LITTLEROCKS_SYSTEM_DECAY;
baseGain_ = LITTLEROCKS_GAIN;
soundDecay_ = LITTLEROCKS_SOUND_DECAY;
decayScale_ = 0.95;
varyFactor_ = 0.18;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type > 11 && type < 19 ) { // Nextmug
nResonances_ = NEXTMUG_RESONANCES;
if ( type > 12 ) // mug + coin
nResonances_ += COIN_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = NEXTMUG_NUM_PARTS;
for ( int i=0; i<NEXTMUG_RESONANCES; i++ ) {
baseRadii_[i] = NEXTMUG_RADII[i];
baseFrequencies_[i] = NEXTMUG_FREQUENCIES[i];
filters_[i].gain = NEXTMUG_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = NEXTMUG_SYSTEM_DECAY;
baseGain_ = NEXTMUG_GAIN;
soundDecay_ = NEXTMUG_SOUND_DECAY;
decayScale_ = 0.95;
setEqualization( 1.0, 0.0, -1.0 );
// Add coins
if ( type == 13 ) { // Mug + Penny
for ( int i=0; i<COIN_RESONANCES; i++ ) {
baseRadii_[i+NEXTMUG_RESONANCES] = PENNY_RADII[i];
baseFrequencies_[i+NEXTMUG_RESONANCES] = PENNY_FREQUENCIES[i];
filters_[i+NEXTMUG_RESONANCES].gain = PENNY_GAINS[i];
doVaryFrequency_[i+NEXTMUG_RESONANCES] = false;
}
}
else if ( type == 14 ) { // Mug + Nickel
for ( int i=0; i<COIN_RESONANCES; i++ ) {
baseRadii_[i+NEXTMUG_RESONANCES] = NICKEL_RADII[i];
baseFrequencies_[i+NEXTMUG_RESONANCES] = NICKEL_FREQUENCIES[i];
filters_[i+NEXTMUG_RESONANCES].gain = NICKEL_GAINS[i];
doVaryFrequency_[i+NEXTMUG_RESONANCES] = false;
}
}
else if ( type == 15 ) { // Mug + Dime
for ( int i=0; i<COIN_RESONANCES; i++ ) {
baseRadii_[i+NEXTMUG_RESONANCES] = DIME_RADII[i];
baseFrequencies_[i+NEXTMUG_RESONANCES] = DIME_FREQUENCIES[i];
filters_[i+NEXTMUG_RESONANCES].gain = DIME_GAINS[i];
doVaryFrequency_[i+NEXTMUG_RESONANCES] = false;
}
}
else if ( type == 16 ) { // Mug + Quarter
for ( int i=0; i<COIN_RESONANCES; i++ ) {
baseRadii_[i+NEXTMUG_RESONANCES] = QUARTER_RADII[i];
baseFrequencies_[i+NEXTMUG_RESONANCES] = QUARTER_FREQUENCIES[i];
filters_[i+NEXTMUG_RESONANCES].gain = QUARTER_GAINS[i];
doVaryFrequency_[i+NEXTMUG_RESONANCES] = false;
}
}
else if ( type == 17 ) { // Mug + Franc
for ( int i=0; i<COIN_RESONANCES; i++ ) {
baseRadii_[i+NEXTMUG_RESONANCES] = FRANC_RADII[i];
baseFrequencies_[i+NEXTMUG_RESONANCES] = FRANC_FREQUENCIES[i];
filters_[i+NEXTMUG_RESONANCES].gain = FRANC_GAINS[i];
doVaryFrequency_[i+NEXTMUG_RESONANCES] = false;
}
}
else if ( type == 18 ) { // Mug + Peso
for ( int i=0; i<COIN_RESONANCES; i++ ) {
baseRadii_[i+NEXTMUG_RESONANCES] = PESO_RADII[i];
baseFrequencies_[i+NEXTMUG_RESONANCES] = PESO_FREQUENCIES[i];
filters_[i+NEXTMUG_RESONANCES].gain = PESO_GAINS[i];
doVaryFrequency_[i+NEXTMUG_RESONANCES] = false;
}
}
}
else if ( type == 19 ) { // Guiro
nResonances_ = GUIRO_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = GUIRO_NUM_PARTS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = GUIRO_RADII[i];
baseFrequencies_[i] = GUIRO_FREQUENCIES[i];
filters_[i].gain = GUIRO_GAINS[i];
doVaryFrequency_[i] = false;
}
baseGain_ = GUIRO_GAIN;
soundDecay_ = GUIRO_SOUND_DECAY;
ratchetCount_ = 0;
baseRatchetDelta_ = 0.0001;
ratchetDelta_ = baseRatchetDelta_;
lastRatchetValue_ = -1;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 20 ) { // Wrench
nResonances_ = WRENCH_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = WRENCH_NUM_PARTS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = WRENCH_RADII[i];
baseFrequencies_[i] = WRENCH_FREQUENCIES[i];
filters_[i].gain = WRENCH_GAINS[i];
doVaryFrequency_[i] = false;
}
baseGain_ = WRENCH_GAIN;
soundDecay_ = WRENCH_SOUND_DECAY;
ratchetCount_ = 0;
baseRatchetDelta_ = 0.00015;
ratchetDelta_ = baseRatchetDelta_;
lastRatchetValue_ = -1;
setEqualization( 1.0, 0.0, -1.0 );
}
else if ( type == 21 ) { // Water Drops
nResonances_ = WATER_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
tempFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = WATER_NUM_SOURCES;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = WATER_RADII[i];
baseFrequencies_[i] = WATER_FREQUENCIES[i];
tempFrequencies_[i] = WATER_FREQUENCIES[i];
filters_[i].gain = WATER_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = WATER_SYSTEM_DECAY;
baseGain_ = WATER_GAIN;
soundDecay_ = WATER_SOUND_DECAY;
decayScale_ = 0.8;
setEqualization( -1.0, 0.0, 1.0 );
}
else if ( type == 22 ) { // Tuned Bamboo Chimes (Angklung)
nResonances_ = ANGKLUNG_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = ANGKLUNG_NUM_TUBES;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = ANGKLUNG_RADII[i];
baseFrequencies_[i] = ANGKLUNG_FREQUENCIES[i];
filters_[i].gain = ANGKLUNG_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = ANGKLUNG_SYSTEM_DECAY;
baseGain_ = ANGKLUNG_GAIN;
soundDecay_ = ANGKLUNG_SOUND_DECAY;
decayScale_ = 0.7;
setEqualization( 1.0, 0.0, -1.0 );
}
else { // Maraca (default)
shakerType_ = 0;
nResonances_ = MARACA_RESONANCES;
filters_.resize( nResonances_ );
baseFrequencies_.resize( nResonances_ );
baseRadii_.resize( nResonances_ );
doVaryFrequency_.resize( nResonances_ );
baseObjects_ = MARACA_NUM_BEANS;
for ( unsigned int i=0; i<nResonances_; i++ ) {
baseRadii_[i] = MARACA_RADII[i];
baseFrequencies_[i] = MARACA_FREQUENCIES[i];
filters_[i].gain = MARACA_GAINS[i];
doVaryFrequency_[i] = false;
}
baseDecay_ = MARACA_SYSTEM_DECAY;
baseGain_ = MARACA_GAIN;
soundDecay_ = MARACA_SOUND_DECAY;
decayScale_ = 0.97;
setEqualization( 1.0, -1.0, 0.0 );
}
// Set common algorithm variables.
shakeEnergy_ = 0.0;
sndLevel_ = 0.0;
nObjects_ = baseObjects_;
systemDecay_ = baseDecay_;
currentGain_ = log( nObjects_ ) * baseGain_ / nObjects_;
for ( unsigned int i=0; i<nResonances_; i++ )
setResonance( filters_[i], baseFrequencies_[i], baseRadii_[i] );
}
const StkFloat MAX_SHAKE = 1.0;
void Shakers :: noteOn( StkFloat frequency, StkFloat amplitude )
{
// Yep ... pretty kludgey, but it works!
int noteNumber = (int) ((12 * log(frequency/220.0)/log(2.0)) + 57.01) % 32;
if ( shakerType_ != noteNumber ) this->setType( noteNumber );
shakeEnergy_ += amplitude * MAX_SHAKE * 0.1;
if ( shakeEnergy_ > MAX_SHAKE ) shakeEnergy_ = MAX_SHAKE;
if ( shakerType_==19 || shakerType_==20 ) ratchetCount_ += 1;
}
void Shakers :: noteOff( StkFloat amplitude )
{
shakeEnergy_ = 0.0;
if ( shakerType_==19 || shakerType_==20 ) ratchetCount_ = 0;
}
void Shakers :: controlChange( int number, StkFloat value )
{
#if defined(_STK_DEBUG_)
if ( Stk::inRange( value, 0.0, 128.0 ) == false ) {
oStream_ << "Shakers::controlChange: value (" << value << ") is out of range!";
handleError( StkError::WARNING ); return;
}
#endif
StkFloat normalizedValue = value * ONE_OVER_128;
if ( number == __SK_Breath_ || number == __SK_AfterTouch_Cont_ ) { // 2 or 128 ... energy
if ( shakerType_ == 19 || shakerType_ == 20 ) {
if ( lastRatchetValue_ < 0.0 ) ratchetCount_++;
else ratchetCount_ = (int) fabs(value - lastRatchetValue_);
ratchetDelta_ = baseRatchetDelta_ * ratchetCount_;
lastRatchetValue_ = (int) value;
}
else {
shakeEnergy_ += normalizedValue * MAX_SHAKE * 0.1;
if ( shakeEnergy_ > MAX_SHAKE ) shakeEnergy_ = MAX_SHAKE;
}
}
else if ( number == __SK_ModFrequency_ ) { // 4 ... decay
systemDecay_ = baseDecay_ + ( 2.0 * (normalizedValue - 0.5) * decayScale_ * (1.0 - baseDecay_) );
}
else if ( number == __SK_FootControl_ ) { // 11 ... number of objects
nObjects_ = (StkFloat) ( 2.0 * normalizedValue * baseObjects_ ) + 1.1;
currentGain_ = log( nObjects_ ) * baseGain_ / nObjects_;
}
else if ( number == __SK_ModWheel_ ) { // 1 ... resonance frequency
for ( unsigned int i=0; i<nResonances_; i++ ) {
StkFloat temp = baseFrequencies_[i] * pow( 4.0, normalizedValue-0.5 );
setResonance( filters_[i], temp, baseRadii_[i] );
}
}
else if (number == __SK_ShakerInst_) { // 1071
unsigned int type = (unsigned int) (value + 0.5); // Just to be safe
this->setType( type );
}
#if defined(_STK_DEBUG_)
else {
oStream_ << "Shakers::controlChange: undefined control number (" << number << ")!";
handleError( StkError::WARNING );
}
#endif
}
} // stk namespace
Reference in New Issue View Git Blame Copy Permalink