falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1915 Commits
16 Branches
258MB
Tree: aabe155188
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'aabe155188'
${ noResults }
Carla/source/modules/stk/stk/Shakers.cpp

1119 lines
34KB
Raw Blame History 

  1. /***************************************************/

  2. /*! \class Shakers

  3.     \brief PhISEM and PhOLIES class.

  4. 

  5.     PhISEM (Physically Informed Stochastic Event

  6.     Modeling) is an algorithmic approach for

  7.     simulating collisions of multiple independent

  8.     sound producing objects.  This class is a

  9.     meta-model that can simulate a Maraca, Sekere,

  10.     Cabasa, Bamboo Wind Chimes, Water Drops,

  11.     Tambourine, Sleighbells, and a Guiro.

  12. 

  13.     PhOLIES (Physically-Oriented Library of

  14.     Imitated Environmental Sounds) is a similar

  15.     approach for the synthesis of environmental

  16.     sounds.  This class implements simulations of

  17.     breaking sticks, crunchy snow (or not), a

  18.     wrench, sandpaper, and more.

  19. 

  20.     Control Change Numbers: 

  21.        - Shake Energy = 2

  22.        - System Decay = 4

  23.        - Number Of Objects = 11

  24.        - Resonance Frequency = 1

  25.        - Shake Energy = 128

  26.        - Instrument Selection = 1071

  27.         - Maraca = 0

  28.         - Cabasa = 1

  29.         - Sekere = 2

  30.         - Guiro = 3

  31.         - Water Drops = 4

  32.         - Bamboo Chimes = 5

  33.         - Tambourine = 6

  34.         - Sleigh Bells = 7

  35.         - Sticks = 8

  36.         - Crunch = 9

  37.         - Wrench = 10

  38.         - Sand Paper = 11

  39.         - Coke Can = 12

  40.         - Next Mug = 13

  41.         - Penny + Mug = 14

  42.         - Nickle + Mug = 15

  43.         - Dime + Mug = 16

  44.         - Quarter + Mug = 17

  45.         - Franc + Mug = 18

  46.         - Peso + Mug = 19

  47.         - Big Rocks = 20

  48.         - Little Rocks = 21

  49.         - Tuned Bamboo Chimes = 22

  50. 

  51.     by Perry R. Cook, 1995-2011.

  52. */

  53. /***************************************************/

  54. 

  55. #include "Shakers.h"

  56. #include "SKINI.msg"

  57. #include <cstring>

  58. #include <cmath>

  59. #include <cstdlib>

  60. 

  61. namespace stk {

  62. 

  63. int my_random( int max ) //  Return Random Int Between 0 and max

  64. {

  65.   int temp = (int) ((float)max * rand() / (RAND_MAX + 1.0) );

  66.   return temp;

  67. }

  68. 

  69. StkFloat float_random( StkFloat max ) // Return random float between 0.0 and max

  70. {	

  71.   StkFloat temp = (StkFloat) (max * rand() / (RAND_MAX + 1.0) );

  72.   return temp;

  73. }

  74. 

  75. StkFloat noise_tick( void ) //  Return random StkFloat float between -1.0 and 1.0

  76. {

  77.   StkFloat temp = (StkFloat) (2.0 * rand() / (RAND_MAX + 1.0) );

  78.   temp -= 1.0;

  79.   return temp;

  80. }

  81. 

  82. // Maraca

  83. const StkFloat MARA_SOUND_DECAY = 0.95;

  84. const StkFloat MARA_SYSTEM_DECAY = 0.999;

  85. const StkFloat MARA_GAIN = 20.0;

  86. const StkFloat MARA_NUM_BEANS = 25;

  87. const StkFloat MARA_CENTER_FREQ = 3200.0;

  88. const StkFloat MARA_RESON = 0.96;

  89. 

  90. // Sekere

  91. const StkFloat SEKE_SOUND_DECAY = 0.96;

  92. const StkFloat SEKE_SYSTEM_DECAY = 0.999;

  93. const StkFloat SEKE_GAIN = 20.0;

  94. const StkFloat SEKE_NUM_BEANS = 64;

  95. const StkFloat SEKE_CENTER_FREQ = 5500.0;

  96. const StkFloat SEKE_RESON = 0.6;

  97. 

  98. // Sandpaper

  99. const StkFloat SANDPAPR_SOUND_DECAY = 0.999;

  100. const StkFloat SANDPAPR_SYSTEM_DECAY = 0.999;

  101. const StkFloat SANDPAPR_GAIN = 0.5;

  102. const StkFloat SANDPAPR_NUM_GRAINS = 128;

  103. const StkFloat SANDPAPR_CENTER_FREQ = 4500.0;

  104. const StkFloat SANDPAPR_RESON = 0.6;

  105. 

  106. // Cabasa

  107. const StkFloat CABA_SOUND_DECAY = 0.96;

  108. const StkFloat CABA_SYSTEM_DECAY = 0.997;

  109. const StkFloat CABA_GAIN = 40.0;

  110. const StkFloat CABA_NUM_BEADS = 512;

  111. const StkFloat CABA_CENTER_FREQ = 3000.0;

  112. const StkFloat CABA_RESON = 0.7;

  113. 

  114. // Bamboo Wind Chimes

  115. const StkFloat BAMB_SOUND_DECAY = 0.95;

  116. const StkFloat BAMB_SYSTEM_DECAY = 0.9999;

  117. const StkFloat BAMB_GAIN = 2.0;

  118. const StkFloat BAMB_NUM_TUBES = 1.25;

  119. const StkFloat BAMB_CENTER_FREQ0 = 2800.0;

  120. const StkFloat BAMB_CENTER_FREQ1 = 0.8 * 2800.0;

  121. const StkFloat BAMB_CENTER_FREQ2 = 1.2 * 2800.0;

  122. const StkFloat BAMB_RESON	= 0.995;

  123. 

  124. // Tuned Bamboo Wind Chimes (Anklung)

  125. const StkFloat TBAMB_SOUND_DECAY = 0.95;

  126. const StkFloat TBAMB_SYSTEM_DECAY = 0.9999;

  127. const StkFloat TBAMB_GAIN = 1.0;

  128. const StkFloat TBAMB_NUM_TUBES = 1.25;

  129. const StkFloat TBAMB_CENTER_FREQ0 = 1046.6;

  130. const StkFloat TBAMB_CENTER_FREQ1 = 1174.8;

  131. const StkFloat TBAMB_CENTER_FREQ2 = 1397.0;

  132. const StkFloat TBAMB_CENTER_FREQ3 = 1568.0;

  133. const StkFloat TBAMB_CENTER_FREQ4 = 1760.0;

  134. const StkFloat TBAMB_CENTER_FREQ5 = 2093.3;

  135. const StkFloat TBAMB_CENTER_FREQ6 = 2350.0;

  136. const StkFloat TBAMB_RESON = 0.996;

  137. 

  138. // Water Drops

  139. const StkFloat WUTR_SOUND_DECAY = 0.95;

  140. const StkFloat WUTR_SYSTEM_DECAY = 0.996;

  141. const StkFloat WUTR_GAIN = 1.0;

  142. const StkFloat WUTR_NUM_SOURCES = 10;

  143. const StkFloat WUTR_CENTER_FREQ0 = 450.0;

  144. const StkFloat WUTR_CENTER_FREQ1 = 600.0;

  145. const StkFloat WUTR_CENTER_FREQ2 = 750.0;

  146. const StkFloat WUTR_RESON = 0.9985;

  147. const StkFloat WUTR_FREQ_SWEEP = 1.0001;

  148. 

  149. // Tambourine

  150. const StkFloat TAMB_SOUND_DECAY = 0.95;

  151. const StkFloat TAMB_SYSTEM_DECAY = 0.9985;

  152. const StkFloat TAMB_GAIN = 5.0;

  153. const StkFloat TAMB_NUM_TIMBRELS = 32;

  154. const StkFloat TAMB_SHELL_FREQ = 2300;

  155. const StkFloat TAMB_SHELL_GAIN = 0.1;

  156. const StkFloat TAMB_SHELL_RESON = 0.96;

  157. const StkFloat TAMB_CYMB_FREQ1 = 5600;

  158. const StkFloat TAMB_CYMB_FREQ2 = 8100;

  159. const StkFloat TAMB_CYMB_RESON = 0.99;

  160. 

  161. // Sleighbells

  162. const StkFloat SLEI_SOUND_DECAY = 0.97;

  163. const StkFloat SLEI_SYSTEM_DECAY = 0.9994;

  164. const StkFloat SLEI_GAIN = 1.0;

  165. const StkFloat SLEI_NUM_BELLS = 32;

  166. const StkFloat SLEI_CYMB_FREQ0 = 2500;

  167. const StkFloat SLEI_CYMB_FREQ1 = 5300;

  168. const StkFloat SLEI_CYMB_FREQ2 = 6500;

  169. const StkFloat SLEI_CYMB_FREQ3 = 8300;

  170. const StkFloat SLEI_CYMB_FREQ4 = 9800;

  171. const StkFloat SLEI_CYMB_RESON = 0.99;

  172. 

  173. // Guiro

  174. const StkFloat GUIR_SOUND_DECAY = 0.95;

  175. const StkFloat GUIR_GAIN = 10.0;

  176. const StkFloat GUIR_NUM_PARTS = 128;

  177. const StkFloat GUIR_GOURD_FREQ = 2500.0;

  178. const StkFloat GUIR_GOURD_RESON = 0.97;

  179. const StkFloat GUIR_GOURD_FREQ2 = 4000.0;

  180. const StkFloat GUIR_GOURD_RESON2 = 0.97;

  181. 

  182. // Wrench

  183. const StkFloat WRENCH_SOUND_DECAY = 0.95;

  184. const StkFloat WRENCH_GAIN = 5;

  185. const StkFloat WRENCH_NUM_PARTS = 128;

  186. const StkFloat WRENCH_FREQ = 3200.0;

  187. const StkFloat WRENCH_RESON = 0.99;

  188. const StkFloat WRENCH_FREQ2 = 8000.0;

  189. const StkFloat WRENCH_RESON2 = 0.992;

  190. 

  191. // Cokecan

  192. const StkFloat COKECAN_SOUND_DECAY = 0.97;

  193. const StkFloat COKECAN_SYSTEM_DECAY = 0.999;

  194. const StkFloat COKECAN_GAIN = 0.8;

  195. const StkFloat COKECAN_NUM_PARTS = 48;

  196. const StkFloat COKECAN_HELMFREQ = 370;

  197. const StkFloat COKECAN_HELM_RES = 0.99;

  198. const StkFloat COKECAN_METLFREQ0 = 1025;

  199. const StkFloat COKECAN_METLFREQ1 = 1424;

  200. const StkFloat COKECAN_METLFREQ2 = 2149;

  201. const StkFloat COKECAN_METLFREQ3 = 3596;

  202. const StkFloat COKECAN_METL_RES = 0.992;

  203. 

  204. // PhOLIES (Physically-Oriented Library of Imitated Environmental

  205. // Sounds), Perry Cook, 1997-8

  206. 

  207. // Stix1

  208. const StkFloat STIX1_SOUND_DECAY = 0.96;

  209. const StkFloat STIX1_SYSTEM_DECAY = 0.998;

  210. const StkFloat STIX1_GAIN = 30.0;

  211. const StkFloat STIX1_NUM_BEANS = 2;

  212. const StkFloat STIX1_CENTER_FREQ = 5500.0;

  213. const StkFloat STIX1_RESON = 0.6;

  214. 

  215. // Crunch1

  216. const StkFloat CRUNCH1_SOUND_DECAY = 0.95;

  217. const StkFloat CRUNCH1_SYSTEM_DECAY = 0.99806;

  218. const StkFloat CRUNCH1_GAIN = 20.0;

  219. const StkFloat CRUNCH1_NUM_BEADS = 7;

  220. const StkFloat CRUNCH1_CENTER_FREQ = 800.0;

  221. const StkFloat CRUNCH1_RESON = 0.95;

  222. 

  223. // Nextmug

  224. const StkFloat NEXTMUG_SOUND_DECAY = 0.97;

  225. const StkFloat NEXTMUG_SYSTEM_DECAY = 0.9995;

  226. const StkFloat NEXTMUG_GAIN = 0.8;

  227. const StkFloat NEXTMUG_NUM_PARTS = 3;

  228. const StkFloat NEXTMUG_FREQ0 = 2123;

  229. const StkFloat NEXTMUG_FREQ1 = 4518;

  230. const StkFloat NEXTMUG_FREQ2 = 8856;

  231. const StkFloat NEXTMUG_FREQ3 = 10753;

  232. const StkFloat NEXTMUG_RES = 0.997;

  233. 

  234. const StkFloat PENNY_FREQ0 = 11000;

  235. const StkFloat PENNY_FREQ1 = 5200;

  236. const StkFloat PENNY_FREQ2 = 3835;

  237. const StkFloat PENNY_RES   = 0.999;

  238. 

  239. const StkFloat NICKEL_FREQ0 = 5583;

  240. const StkFloat NICKEL_FREQ1 = 9255;

  241. const StkFloat NICKEL_FREQ2 = 9805;

  242. const StkFloat NICKEL_RES = 0.9992;

  243. 

  244. const StkFloat DIME_FREQ0 = 4450;

  245. const StkFloat DIME_FREQ1 = 4974;

  246. const StkFloat DIME_FREQ2 = 9945;

  247. const StkFloat DIME_RES = 0.9993;

  248. 

  249. const StkFloat QUARTER_FREQ0 = 1708;

  250. const StkFloat QUARTER_FREQ1 = 8863;

  251. const StkFloat QUARTER_FREQ2 = 9045;

  252. const StkFloat QUARTER_RES = 0.9995;

  253. 

  254. const StkFloat FRANC_FREQ0 = 5583;

  255. const StkFloat FRANC_FREQ1 = 11010;

  256. const StkFloat FRANC_FREQ2 = 1917;

  257. const StkFloat FRANC_RES = 0.9995;

  258. 

  259. const StkFloat PESO_FREQ0 = 7250;

  260. const StkFloat PESO_FREQ1 = 8150;

  261. const StkFloat PESO_FREQ2 = 10060;

  262. const StkFloat PESO_RES = 0.9996;

  263. 

  264. // Big Gravel

  265. const StkFloat BIGROCKS_SOUND_DECAY = 0.98;

  266. const StkFloat BIGROCKS_SYSTEM_DECAY = 0.9965;

  267. const StkFloat BIGROCKS_GAIN = 20.0;

  268. const StkFloat BIGROCKS_NUM_PARTS = 23;

  269. const StkFloat BIGROCKS_FREQ = 6460;

  270. const StkFloat BIGROCKS_RES = 0.932;

  271. 

  272. // Little Gravel

  273. const StkFloat LITLROCKS_SOUND_DECAY = 0.98;

  274. const StkFloat LITLROCKS_SYSTEM_DECAY = 0.99586;

  275. const StkFloat LITLROCKS_GAIN = 20.0;

  276. const StkFloat LITLROCKS_NUM_PARTS = 1600;

  277. const StkFloat LITLROCKS_FREQ = 9000;

  278. const StkFloat LITLROCKS_RES = 0.843;

  279. 

  280. // Finally ... the class code!

  281. 

  282. Shakers :: Shakers( void )

  283. {

  284.   int i;

  285. 

  286.   instType_ = 0;

  287.   shakeEnergy_ = 0.0;

  288.   nFreqs_ = 0;

  289.   sndLevel_ = 0.0;

  290. 

  291.   for ( i=0; i<MAX_FREQS; i++ )	{

  292.     inputs_[i] = 0.0;

  293.     outputs_[i][0] = 0.0;

  294.     outputs_[i][1] = 0.0;

  295.     coeffs_[i][0] = 0.0;

  296.     coeffs_[i][1] = 0.0;

  297.     gains_[i] = 0.0;

  298.     center_freqs_[i] = 0.0;

  299.     resons_[i] =  0.0;

  300.     freq_rand_[i] = 0.0;

  301.     freqalloc_[i] = 0;

  302.   }

  303. 

  304.   soundDecay_ = 0.0;

  305.   systemDecay_ = 0.0;

  306.   nObjects_ = 0.0;

  307.   totalEnergy_ = 0.0;

  308.   ratchet_ = 0.0;

  309.   ratchetDelta_ = 0.0005;

  310.   lastRatchetPos_ = 0;

  311.   finalZ_[0] = 0.0;

  312.   finalZ_[1] = 0.0;

  313.   finalZ_[2] = 0.0;

  314.   finalZCoeffs_[0] = 1.0;

  315.   finalZCoeffs_[1] = 0.0;

  316.   finalZCoeffs_[2] = 0.0;

  317. 

  318.   this->setupNum(instType_);

  319. }

  320. 

  321. Shakers :: ~Shakers( void )

  322. {

  323. }

  324. 

  325. const StkFloat MAX_SHAKE = 2000.0;

  326. 

  327. char instrs[NUM_INSTR][10] = {

  328.   "Maraca", "Cabasa", "Sekere", "Guiro",

  329.   "Waterdrp", "Bamboo", "Tambourn", "Sleighbl", 

  330.   "Stix1", "Crunch1", "Wrench", "SandPapr",

  331.   "CokeCan", "NextMug", "PennyMug", "NicklMug",

  332.   "DimeMug", "QuartMug", "FrancMug", "PesoMug",

  333.   "BigRocks", "LitlRoks", "TBamboo"

  334. };

  335. 

  336. int Shakers :: setupName( char* instr )

  337. {

  338.   int which = 0;

  339. 

  340.   for ( int i=0; i<NUM_INSTR; i++ )	{

  341.     if ( !strcmp(instr,instrs[i]) )

  342. 	    which = i;

  343.   }

  344. 

  345.   return this->setupNum( which );

  346. }

  347. 

  348. void Shakers :: setFinalZs( StkFloat z0, StkFloat z1, StkFloat z2 )

  349. {

  350.   finalZCoeffs_[0] = z0;

  351.   finalZCoeffs_[1] = z1;

  352.   finalZCoeffs_[2] = z2;

  353. }

  354. 

  355. void Shakers :: setDecays( StkFloat sndDecay, StkFloat sysDecay )

  356. {

  357.   soundDecay_ = sndDecay;

  358.   systemDecay_ = sysDecay;

  359. }

  360. 

  361. int Shakers :: setFreqAndReson( int which, StkFloat freq, StkFloat reson )

  362. {

  363.   if ( which < MAX_FREQS )	{

  364.     resons_[which] = reson;

  365.     center_freqs_[which] = freq;

  366.     t_center_freqs_[which] = freq;

  367.     coeffs_[which][1] = reson * reson;

  368.     coeffs_[which][0] = -reson * 2.0 * cos(freq * TWO_PI / Stk::sampleRate());

  369.     return 1;

  370.   }

  371.   else return 0;

  372. }

  373. 

  374. int Shakers :: setupNum( int inst )

  375. {

  376.   int i, rv = 0;

  377.   StkFloat temp;

  378. 

  379.   if (inst == 1) { // Cabasa

  380.     rv = inst;

  381.     nObjects_ = CABA_NUM_BEADS;

  382.     defObjs_[inst] = CABA_NUM_BEADS;

  383.     setDecays(CABA_SOUND_DECAY, CABA_SYSTEM_DECAY);

  384.     defDecays_[inst] = CABA_SYSTEM_DECAY;

  385.     decayScale_[inst] = 0.97;

  386.     nFreqs_ = 1;

  387.     baseGain_ = CABA_GAIN;

  388.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  389.     gains_[0] = temp;

  390.     freqalloc_[0] = 0;

  391.     setFreqAndReson(0,CABA_CENTER_FREQ,CABA_RESON);

  392.     setFinalZs(1.0,-1.0,0.0);

  393.   }

  394.   else if (inst == 2) { // Sekere

  395.     rv = inst;

  396.     nObjects_ = SEKE_NUM_BEANS;

  397.     defObjs_[inst] = SEKE_NUM_BEANS;

  398.     this->setDecays(SEKE_SOUND_DECAY,SEKE_SYSTEM_DECAY);

  399.     defDecays_[inst] = SEKE_SYSTEM_DECAY;

  400.     decayScale_[inst] = 0.94;

  401.     nFreqs_ = 1;

  402.     baseGain_ = SEKE_GAIN;

  403.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  404.     gains_[0] = temp;

  405.     freqalloc_[0] = 0;

  406.     this->setFreqAndReson(0,SEKE_CENTER_FREQ,SEKE_RESON);

  407.     this->setFinalZs(1.0, 0.0, -1.0);

  408.   }

  409.   else if (inst == 3) { //  Guiro

  410.     rv = inst;

  411.     nObjects_ = GUIR_NUM_PARTS;

  412.     defObjs_[inst] = GUIR_NUM_PARTS;

  413.     setDecays(GUIR_SOUND_DECAY,1.0);

  414.     defDecays_[inst] = 0.9999;

  415.     decayScale_[inst] = 1.0;

  416.     nFreqs_ = 2;

  417.     baseGain_ = GUIR_GAIN;

  418.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  419.     gains_[0]=temp;

  420.     gains_[1]=temp;

  421.     freqalloc_[0] = 0;

  422.     freqalloc_[1] = 0;

  423.     freq_rand_[0] = 0.0;

  424.     freq_rand_[1] = 0.0;

  425.     setFreqAndReson(0,GUIR_GOURD_FREQ,GUIR_GOURD_RESON);

  426.     setFreqAndReson(1,GUIR_GOURD_FREQ2,GUIR_GOURD_RESON2);

  427.     ratchet_ = 0;

  428.     ratchetPos_ = 10;

  429.   }

  430.   else if (inst == 4) { //  Water Drops

  431.     rv = inst;

  432.     nObjects_ = WUTR_NUM_SOURCES;

  433.     defObjs_[inst] = WUTR_NUM_SOURCES;

  434.     setDecays(WUTR_SOUND_DECAY,WUTR_SYSTEM_DECAY);

  435.     defDecays_[inst] = WUTR_SYSTEM_DECAY;

  436.     decayScale_[inst] = 0.8;

  437.     nFreqs_ = 3;

  438.     baseGain_ = WUTR_GAIN;

  439.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  440.     gains_[0]=temp;

  441.     gains_[1]=temp;

  442.     gains_[2]=temp;

  443.     freqalloc_[0] = 1;

  444.     freqalloc_[1] = 1;

  445.     freqalloc_[2] = 1;

  446.     freq_rand_[0] = 0.2;

  447.     freq_rand_[1] = 0.2;

  448.     freq_rand_[2] = 0.2;

  449.     setFreqAndReson(0,WUTR_CENTER_FREQ0,WUTR_RESON);

  450.     setFreqAndReson(1,WUTR_CENTER_FREQ0,WUTR_RESON);

  451.     setFreqAndReson(2,WUTR_CENTER_FREQ0,WUTR_RESON);

  452.     setFinalZs(1.0,0.0,0.0);

  453.   }

  454.   else if (inst == 5) { // Bamboo

  455.     rv = inst;

  456.     nObjects_ = BAMB_NUM_TUBES;

  457.     defObjs_[inst] = BAMB_NUM_TUBES;

  458.     setDecays(BAMB_SOUND_DECAY, BAMB_SYSTEM_DECAY);

  459.     defDecays_[inst] = BAMB_SYSTEM_DECAY;

  460.     decayScale_[inst] = 0.7;

  461.     nFreqs_ = 3;

  462.     baseGain_ = BAMB_GAIN;

  463.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  464.     gains_[0]=temp;

  465.     gains_[1]=temp;

  466.     gains_[2]=temp;

  467.     freqalloc_[0] = 1;

  468.     freqalloc_[1] = 1;

  469.     freqalloc_[2] = 1;

  470.     freq_rand_[0] = 0.2;

  471.     freq_rand_[1] = 0.2;

  472.     freq_rand_[2] = 0.2;

  473.     setFreqAndReson(0,BAMB_CENTER_FREQ0,BAMB_RESON);

  474.     setFreqAndReson(1,BAMB_CENTER_FREQ1,BAMB_RESON);

  475.     setFreqAndReson(2,BAMB_CENTER_FREQ2,BAMB_RESON);

  476.     setFinalZs(1.0,0.0,0.0);

  477.   }

  478.   else if (inst == 6) { // Tambourine

  479.     rv = inst;

  480.     nObjects_ = TAMB_NUM_TIMBRELS;

  481.     defObjs_[inst] = TAMB_NUM_TIMBRELS;

  482.     setDecays(TAMB_SOUND_DECAY,TAMB_SYSTEM_DECAY);

  483.     defDecays_[inst] = TAMB_SYSTEM_DECAY;

  484.     decayScale_[inst] = 0.95;

  485.     nFreqs_ = 3;

  486.     baseGain_ = TAMB_GAIN;

  487.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  488.     gains_[0]=temp*TAMB_SHELL_GAIN;

  489.     gains_[1]=temp*0.8;

  490.     gains_[2]=temp;

  491.     freqalloc_[0] = 0;

  492.     freqalloc_[1] = 1;

  493.     freqalloc_[2] = 1;

  494.     freq_rand_[0] = 0.0;

  495.     freq_rand_[1] = 0.05;

  496.     freq_rand_[2] = 0.05;

  497.     setFreqAndReson(0,TAMB_SHELL_FREQ,TAMB_SHELL_RESON);

  498.     setFreqAndReson(1,TAMB_CYMB_FREQ1,TAMB_CYMB_RESON);

  499.     setFreqAndReson(2,TAMB_CYMB_FREQ2,TAMB_CYMB_RESON);

  500.     setFinalZs(1.0,0.0,-1.0);

  501.   }

  502.   else if (inst == 7) { // Sleighbell

  503.     rv = inst;

  504.     nObjects_ = SLEI_NUM_BELLS;

  505.     defObjs_[inst] = SLEI_NUM_BELLS;

  506.     setDecays(SLEI_SOUND_DECAY,SLEI_SYSTEM_DECAY);

  507.     defDecays_[inst] = SLEI_SYSTEM_DECAY;

  508.     decayScale_[inst] = 0.9;

  509.     nFreqs_ = 5;

  510.     baseGain_ = SLEI_GAIN;

  511.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  512.     gains_[0]=temp;

  513.     gains_[1]=temp;

  514.     gains_[2]=temp;

  515.     gains_[3]=temp*0.5;

  516.     gains_[4]=temp*0.3;

  517.     for (i=0;i<nFreqs_;i++)	{

  518. 	    freqalloc_[i] = 1;

  519. 	    freq_rand_[i] = 0.03;

  520.     }

  521.     setFreqAndReson(0,SLEI_CYMB_FREQ0,SLEI_CYMB_RESON);

  522.     setFreqAndReson(1,SLEI_CYMB_FREQ1,SLEI_CYMB_RESON);

  523.     setFreqAndReson(2,SLEI_CYMB_FREQ2,SLEI_CYMB_RESON);

  524.     setFreqAndReson(3,SLEI_CYMB_FREQ3,SLEI_CYMB_RESON);

  525.     setFreqAndReson(4,SLEI_CYMB_FREQ4,SLEI_CYMB_RESON);

  526.     setFinalZs(1.0,0.0,-1.0);

  527.   }

  528.   else if (inst == 8) { // Stix1

  529.     rv = inst;

  530.     nObjects_ = STIX1_NUM_BEANS;

  531.     defObjs_[inst] = STIX1_NUM_BEANS;

  532.     setDecays(STIX1_SOUND_DECAY,STIX1_SYSTEM_DECAY);

  533.     defDecays_[inst] = STIX1_SYSTEM_DECAY;

  534. 

  535.     decayScale_[inst] = 0.96;

  536.     nFreqs_ = 1;

  537.     baseGain_ = STIX1_GAIN;

  538.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  539.     gains_[0]=temp;

  540.     freqalloc_[0] = 0;

  541.     setFreqAndReson(0,STIX1_CENTER_FREQ,STIX1_RESON);

  542.     setFinalZs(1.0,0.0,-1.0);

  543.   }

  544.   else if (inst == 9) { // Crunch1

  545.     rv = inst;

  546.     nObjects_ = CRUNCH1_NUM_BEADS;

  547.     defObjs_[inst] = CRUNCH1_NUM_BEADS;

  548.     setDecays(CRUNCH1_SOUND_DECAY,CRUNCH1_SYSTEM_DECAY);

  549.     defDecays_[inst] = CRUNCH1_SYSTEM_DECAY;

  550.     decayScale_[inst] = 0.96;

  551.     nFreqs_ = 1;

  552.     baseGain_ = CRUNCH1_GAIN;

  553.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  554.     gains_[0]=temp;

  555.     freqalloc_[0] = 0;

  556.     setFreqAndReson(0,CRUNCH1_CENTER_FREQ,CRUNCH1_RESON);

  557.     setFinalZs(1.0,-1.0,0.0);

  558.   }

  559.   else if (inst == 10) { // Wrench

  560.     rv = inst;

  561.     nObjects_ = WRENCH_NUM_PARTS;

  562.     defObjs_[inst] = WRENCH_NUM_PARTS;

  563.     setDecays(WRENCH_SOUND_DECAY,1.0);

  564.     defDecays_[inst] = 0.9999;

  565.     decayScale_[inst] = 0.98;

  566.     nFreqs_ = 2;

  567.     baseGain_ = WRENCH_GAIN;

  568.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  569.     gains_[0]=temp;

  570.     gains_[1]=temp;

  571.     freqalloc_[0] = 0;

  572.     freqalloc_[1] = 0;

  573.     freq_rand_[0] = 0.0;

  574.     freq_rand_[1] = 0.0;

  575.     setFreqAndReson(0,WRENCH_FREQ,WRENCH_RESON);

  576.     setFreqAndReson(1,WRENCH_FREQ2,WRENCH_RESON2);

  577.     ratchet_ = 0;

  578.     ratchetPos_ = 10;

  579.   }

  580.   else if (inst == 11) { // Sandpapr

  581.     rv = inst;

  582.     nObjects_ = SANDPAPR_NUM_GRAINS;

  583.     defObjs_[inst] = SANDPAPR_NUM_GRAINS;

  584.     this->setDecays(SANDPAPR_SOUND_DECAY,SANDPAPR_SYSTEM_DECAY);

  585.     defDecays_[inst] = SANDPAPR_SYSTEM_DECAY;

  586.     decayScale_[inst] = 0.97;

  587.     nFreqs_ = 1;

  588.     baseGain_ = SANDPAPR_GAIN;

  589.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  590.     gains_[0] = temp;

  591.     freqalloc_[0] = 0;

  592.     this->setFreqAndReson(0,SANDPAPR_CENTER_FREQ,SANDPAPR_RESON);

  593.     this->setFinalZs(1.0, 0.0, -1.0);

  594.   }

  595.   else if (inst == 12) { // Cokecan

  596.     rv = inst;

  597.     nObjects_ = COKECAN_NUM_PARTS;

  598.     defObjs_[inst] = COKECAN_NUM_PARTS;

  599.     setDecays(COKECAN_SOUND_DECAY,COKECAN_SYSTEM_DECAY);

  600.     defDecays_[inst] = COKECAN_SYSTEM_DECAY;

  601.     decayScale_[inst] = 0.95;

  602.     nFreqs_ = 5;

  603.     baseGain_ = COKECAN_GAIN;

  604.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  605.     gains_[0]=temp;

  606.     gains_[1]=temp*1.8;

  607.     gains_[2]=temp*1.8;

  608.     gains_[3]=temp*1.8;

  609.     gains_[4]=temp*1.8;

  610.     freqalloc_[0] = 0;

  611.     freqalloc_[1] = 0;

  612.     freqalloc_[2] = 0;

  613.     freqalloc_[3] = 0;

  614.     freqalloc_[4] = 0;

  615.     setFreqAndReson(0,COKECAN_HELMFREQ,COKECAN_HELM_RES);

  616.     setFreqAndReson(1,COKECAN_METLFREQ0,COKECAN_METL_RES);

  617.     setFreqAndReson(2,COKECAN_METLFREQ1,COKECAN_METL_RES);

  618.     setFreqAndReson(3,COKECAN_METLFREQ2,COKECAN_METL_RES);

  619.     setFreqAndReson(4,COKECAN_METLFREQ3,COKECAN_METL_RES);

  620.     setFinalZs(1.0,0.0,-1.0);

  621.   }

  622.   else if (inst>12 && inst<20) { // Nextmug

  623.     rv = inst;

  624.     nObjects_ = NEXTMUG_NUM_PARTS;

  625.     defObjs_[inst] = NEXTMUG_NUM_PARTS;

  626.     setDecays(NEXTMUG_SOUND_DECAY,NEXTMUG_SYSTEM_DECAY);

  627.     defDecays_[inst] = NEXTMUG_SYSTEM_DECAY;

  628.     decayScale_[inst] = 0.95;

  629.     nFreqs_ = 4;

  630.     baseGain_ = NEXTMUG_GAIN;

  631.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  632.     gains_[0]=temp;

  633.     gains_[1]=temp*0.8;

  634.     gains_[2]=temp*0.6;

  635.     gains_[3]=temp*0.4;

  636.     freqalloc_[0] = 0;

  637.     freqalloc_[1] = 0;

  638.     freqalloc_[2] = 0;

  639.     freqalloc_[3] = 0;

  640.     freqalloc_[4] = 0;

  641.     freqalloc_[5] = 0;

  642.     setFreqAndReson(0,NEXTMUG_FREQ0,NEXTMUG_RES);

  643.     setFreqAndReson(1,NEXTMUG_FREQ1,NEXTMUG_RES);

  644.     setFreqAndReson(2,NEXTMUG_FREQ2,NEXTMUG_RES);

  645.     setFreqAndReson(3,NEXTMUG_FREQ3,NEXTMUG_RES);

  646.     setFinalZs(1.0,0.0,-1.0);

  647. 

  648.     if (inst == 14) { // Mug + Penny

  649.       nFreqs_ = 7;

  650.       gains_[4] = temp;

  651.       gains_[5] = temp*0.8;

  652.       gains_[6] = temp*0.5;

  653.       setFreqAndReson(4,PENNY_FREQ0,PENNY_RES);

  654.       setFreqAndReson(5,PENNY_FREQ1,PENNY_RES);

  655.       setFreqAndReson(6,PENNY_FREQ2,PENNY_RES);

  656.     }

  657.     else if (inst == 15) { // Mug + Nickel

  658.       nFreqs_ = 6;

  659.       gains_[4] = temp;

  660.       gains_[5] = temp*0.8;

  661.       gains_[6] = temp*0.5;

  662.       setFreqAndReson(4,NICKEL_FREQ0,NICKEL_RES);

  663.       setFreqAndReson(5,NICKEL_FREQ1,NICKEL_RES);

  664.       setFreqAndReson(6,NICKEL_FREQ2,NICKEL_RES);

  665.     }

  666.     else if (inst == 16) { // Mug + Dime

  667.       nFreqs_ = 6;

  668.       gains_[4] = temp;

  669.       gains_[5] = temp*0.8;

  670.       gains_[6] = temp*0.5;

  671.       setFreqAndReson(4,DIME_FREQ0,DIME_RES);

  672.       setFreqAndReson(5,DIME_FREQ1,DIME_RES);

  673.       setFreqAndReson(6,DIME_FREQ2,DIME_RES);

  674.     }

  675.     else if (inst == 17) { // Mug + Quarter

  676.       nFreqs_ = 6;

  677.       gains_[4] = temp*1.3;

  678.       gains_[5] = temp*1.0;

  679.       gains_[6] = temp*0.8;

  680.       setFreqAndReson(4,QUARTER_FREQ0,QUARTER_RES);

  681.       setFreqAndReson(5,QUARTER_FREQ1,QUARTER_RES);

  682.       setFreqAndReson(6,QUARTER_FREQ2,QUARTER_RES);

  683.     }

  684.     else if (inst == 18) { // Mug + Franc

  685.       nFreqs_ = 6;

  686.       gains_[4] = temp*0.7;

  687.       gains_[5] = temp*0.4;

  688.       gains_[6] = temp*0.3;

  689.       setFreqAndReson(4,FRANC_FREQ0,FRANC_RES);

  690.       setFreqAndReson(5,FRANC_FREQ1,FRANC_RES);

  691.       setFreqAndReson(6,FRANC_FREQ2,FRANC_RES);

  692.     }

  693.     else if (inst == 19) { // Mug + Peso

  694.       nFreqs_ = 6;

  695.       gains_[4] = temp;

  696.       gains_[5] = temp*1.2;

  697.       gains_[6] = temp*0.7;

  698.       setFreqAndReson(4,PESO_FREQ0,PESO_RES);

  699.       setFreqAndReson(5,PESO_FREQ1,PESO_RES);

  700.       setFreqAndReson(6,PESO_FREQ2,PESO_RES);

  701.     }

  702.   }

  703.   else if (inst == 20) { // Big Rocks

  704.     nFreqs_ = 1;

  705.     rv = inst;

  706.     nObjects_ = BIGROCKS_NUM_PARTS;

  707.     defObjs_[inst] = BIGROCKS_NUM_PARTS;

  708.     setDecays(BIGROCKS_SOUND_DECAY,BIGROCKS_SYSTEM_DECAY);

  709.     defDecays_[inst] = BIGROCKS_SYSTEM_DECAY;

  710.     decayScale_[inst] = 0.95;

  711.     baseGain_ = BIGROCKS_GAIN;

  712.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  713.     gains_[0]=temp;

  714.     freqalloc_[0] = 1;

  715.     freq_rand_[0] = 0.11;

  716.     setFreqAndReson(0,BIGROCKS_FREQ,BIGROCKS_RES);

  717.     setFinalZs(1.0,0.0,-1.0);

  718.   }

  719.   else if (inst == 21) { // Little Rocks

  720.     nFreqs_ = 1;

  721.     rv = inst;

  722.     nObjects_ = LITLROCKS_NUM_PARTS;

  723.     defObjs_[inst] = LITLROCKS_NUM_PARTS;

  724.     setDecays(LITLROCKS_SOUND_DECAY,LITLROCKS_SYSTEM_DECAY);

  725.     defDecays_[inst] = LITLROCKS_SYSTEM_DECAY;

  726.     decayScale_[inst] = 0.95;

  727.     baseGain_ = LITLROCKS_GAIN;

  728.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  729.     gains_[0]=temp;

  730.     freqalloc_[0] = 1;

  731.     freq_rand_[0] = 0.18;

  732.     setFreqAndReson(0,LITLROCKS_FREQ,LITLROCKS_RES);

  733.     setFinalZs(1.0,0.0,-1.0);

  734.   }

  735.   else if (inst == 22) { // Tuned Bamboo

  736.     rv = inst;

  737.     nObjects_ = TBAMB_NUM_TUBES;

  738.     defObjs_[inst] = TBAMB_NUM_TUBES;

  739.     setDecays(TBAMB_SOUND_DECAY, TBAMB_SYSTEM_DECAY);

  740.     defDecays_[inst] = TBAMB_SYSTEM_DECAY;

  741.     decayScale_[inst] = 0.7;

  742.     nFreqs_ = 7;

  743.     baseGain_ = TBAMB_GAIN;

  744.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  745.     gains_[0]=temp;

  746.     gains_[1]=temp;

  747.     gains_[2]=temp;

  748.     gains_[3]=temp;

  749.     gains_[4]=temp;

  750.     gains_[5]=temp;

  751.     gains_[6]=temp;

  752.     freqalloc_[0] = 0;

  753.     freqalloc_[1] = 0;

  754.     freqalloc_[2] = 0;

  755.     freqalloc_[3] = 0;

  756.     freqalloc_[4] = 0;

  757.     freqalloc_[5] = 0;

  758.     freqalloc_[6] = 0;

  759.     freq_rand_[0] = 0.0;

  760.     freq_rand_[1] = 0.0;

  761.     freq_rand_[2] = 0.0;

  762.     freq_rand_[3] = 0.0;

  763.     freq_rand_[4] = 0.0;

  764.     freq_rand_[5] = 0.0;

  765.     freq_rand_[6] = 0.0;

  766.     setFreqAndReson(0,TBAMB_CENTER_FREQ0,TBAMB_RESON);

  767.     setFreqAndReson(1,TBAMB_CENTER_FREQ1,TBAMB_RESON);

  768.     setFreqAndReson(2,TBAMB_CENTER_FREQ2,TBAMB_RESON);

  769.     setFreqAndReson(3,TBAMB_CENTER_FREQ3,TBAMB_RESON);

  770.     setFreqAndReson(4,TBAMB_CENTER_FREQ4,TBAMB_RESON);

  771.     setFreqAndReson(5,TBAMB_CENTER_FREQ5,TBAMB_RESON);

  772.     setFreqAndReson(6,TBAMB_CENTER_FREQ6,TBAMB_RESON);

  773.     setFinalZs(1.0,0.0,-1.0);

  774.   }

  775.   else { // Maraca (inst == 0) or default

  776.     rv = 0;

  777.     nObjects_ = MARA_NUM_BEANS;

  778.     defObjs_[0] = MARA_NUM_BEANS;

  779.     setDecays(MARA_SOUND_DECAY,MARA_SYSTEM_DECAY);

  780.     defDecays_[0] = MARA_SYSTEM_DECAY;

  781.     decayScale_[inst] = 0.9;

  782.     nFreqs_ = 1;

  783.     baseGain_ = MARA_GAIN;

  784.     temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  785.     gains_[0]=temp;

  786.     freqalloc_[0] = 0;

  787.     setFreqAndReson(0,MARA_CENTER_FREQ,MARA_RESON);

  788.     setFinalZs(1.0,-1.0,0.0);

  789.   }

  790.   return rv;

  791. }

  792. 

  793. void Shakers :: noteOn( StkFloat frequency, StkFloat amplitude )

  794. {

  795.   // Yep ... pretty kludgey, but it works!

  796.   int noteNum = (int) ((12*log(frequency/220.0)/log(2.0)) + 57.01) % 32;

  797.   if (instType_ !=  noteNum) instType_ = this->setupNum(noteNum);

  798. 

  799.   shakeEnergy_ += amplitude * MAX_SHAKE * 0.1;

  800.   if (shakeEnergy_ > MAX_SHAKE) shakeEnergy_ = MAX_SHAKE;

  801.   if (instType_==10 || instType_==3) ratchetPos_ += 1;

  802. }

  803. 

  804. void Shakers :: noteOff( StkFloat amplitude )

  805. {

  806.   shakeEnergy_ = 0.0;

  807.   if (instType_==10 || instType_==3) ratchetPos_ = 0;

  808. }

  809. 

  810. const StkFloat MIN_ENERGY = 0.3;

  811. 

  812. StkFloat Shakers :: tick( unsigned int )

  813. {

  814.   StkFloat data;

  815.   StkFloat temp_rand;

  816.   int i;

  817. 

  818.   if (instType_ == 4) {

  819.   	if (shakeEnergy_ > MIN_ENERGY)	{

  820.       lastFrame_[0] = wuter_tick();

  821.       lastFrame_[0] *= 0.0001;

  822.     }

  823.     else {

  824.       lastFrame_[0] = 0.0;

  825.     }

  826.   }

  827.   else if (instType_ == 22) {

  828.     lastFrame_[0] = tbamb_tick();

  829.   }

  830.   else if (instType_ == 10 || instType_ == 3) {

  831.     if (ratchetPos_ > 0) {

  832.       ratchet_ -= (ratchetDelta_ + (0.002*totalEnergy_));

  833.       if (ratchet_ < 0.0) {

  834.         ratchet_ = 1.0;

  835.         ratchetPos_ -= 1;

  836. 	    }

  837.       totalEnergy_ = ratchet_;

  838.       lastFrame_[0] = ratchet_tick();

  839.       lastFrame_[0] *= 0.0001;

  840.     }

  841.     else lastFrame_[0] = 0.0;

  842.   }

  843.   else  { // generic_tick()

  844.     if (shakeEnergy_ > MIN_ENERGY) {

  845.       shakeEnergy_ *= systemDecay_;               // Exponential system decay

  846.       if (float_random(1024.0) < nObjects_) {

  847.         sndLevel_ += shakeEnergy_;   

  848.         for (i=0;i<nFreqs_;i++) {

  849.           if (freqalloc_[i])	{

  850.             temp_rand = t_center_freqs_[i] * (1.0 + (freq_rand_[i] * noise_tick()));

  851.             coeffs_[i][0] = -resons_[i] * 2.0 * cos(temp_rand * TWO_PI / Stk::sampleRate());

  852.           }

  853.         }

  854.     	}

  855.       inputs_[0] = sndLevel_ * noise_tick();      // Actual Sound is Random

  856.       for (i=1; i<nFreqs_; i++)	{

  857.         inputs_[i] = inputs_[0];

  858.       }

  859.       sndLevel_ *= soundDecay_;                   // Exponential Sound decay 

  860.       finalZ_[2] = finalZ_[1];

  861.       finalZ_[1] = finalZ_[0];

  862.       finalZ_[0] = 0;

  863.       for (i=0;i<nFreqs_;i++)	{

  864.         inputs_[i] -= outputs_[i][0]*coeffs_[i][0];  // Do

  865.         inputs_[i] -= outputs_[i][1]*coeffs_[i][1];  // resonant

  866.         outputs_[i][1] = outputs_[i][0];            // filter

  867.         outputs_[i][0] = inputs_[i];                // calculations

  868.         finalZ_[0] += gains_[i] * outputs_[i][1];

  869.       }

  870.       data = finalZCoeffs_[0] * finalZ_[0];     // Extra zero(s) for shape

  871.       data += finalZCoeffs_[1] * finalZ_[1];    // Extra zero(s) for shape

  872.       data += finalZCoeffs_[2] * finalZ_[2];    // Extra zero(s) for shape

  873.       if (data > 10000.0)	data = 10000.0;

  874.       if (data < -10000.0) data = -10000.0;

  875.       lastFrame_[0] = data * 0.0001;

  876.     }

  877.     else lastFrame_[0] = 0.0;

  878.   }

  879. 

  880.   return lastFrame_[0];

  881. }

  882. 

  883. void Shakers :: controlChange( int number, StkFloat value )

  884. {

  885. #if defined(_STK_DEBUG_)

  886.   if ( Stk::inRange( value, 0.0, 128.0 ) == false ) {

  887.     oStream_ << "Shakers::controlChange: value (" << value << ") is out of range!";

  888.     handleError( StkError::WARNING ); return;

  889.   }

  890. #endif

  891. 

  892.   int i;

  893.   StkFloat temp;

  894.   StkFloat normalizedValue = value * ONE_OVER_128;

  895.   if (number == __SK_Breath_) { // 2 ... energy

  896.     shakeEnergy_ += normalizedValue * MAX_SHAKE * 0.1;

  897.     if (shakeEnergy_ > MAX_SHAKE) shakeEnergy_ = MAX_SHAKE;

  898.     if (instType_==10 || instType_==3) {

  899. 	    ratchetPos_ = (int) fabs(value - lastRatchetPos_);

  900. 	    ratchetDelta_ = 0.0002 * ratchetPos_;

  901. 	    lastRatchetPos_ = (int) value;

  902.     }

  903.   }

  904.   else if (number == __SK_ModFrequency_) { // 4 ... decay

  905.     if (instType_ != 3 && instType_ != 10) {

  906.       systemDecay_ = defDecays_[instType_] + ((value - 64.0) *

  907.                                            decayScale_[instType_] *

  908.                                            (1.0 - defDecays_[instType_]) / 64.0 );

  909.       gains_[0] = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  910.       for (i=1;i<nFreqs_;i++) gains_[i] = gains_[0];

  911.       if (instType_ == 6) { // tambourine

  912.         gains_[0] *= TAMB_SHELL_GAIN;

  913.         gains_[1] *= 0.8;

  914.       }

  915.       else if (instType_ == 7) { // sleighbell

  916.         gains_[3] *= 0.5;

  917.         gains_[4] *= 0.3;

  918.       }

  919.       else if (instType_ == 12) { // cokecan

  920.         for (i=1;i<nFreqs_;i++) gains_[i] *= 1.8;

  921.       }

  922.       for (i=0;i<nFreqs_;i++) gains_[i] *= ((128-value)/100.0 + 0.36);

  923.     }

  924.   }

  925.   else if (number == __SK_FootControl_) { // 11 ... number of objects

  926.     if (instType_ == 5) // bamboo

  927.       nObjects_ = (StkFloat) (value * defObjs_[instType_] / 64.0) + 0.3;

  928.     else

  929.       nObjects_ = (StkFloat) (value * defObjs_[instType_] / 64.0) + 1.1;

  930.     gains_[0] = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;

  931.     for (i=1;i<nFreqs_;i++) gains_[i] = gains_[0];

  932.     if (instType_ == 6) { // tambourine

  933.       gains_[0] *= TAMB_SHELL_GAIN;

  934.       gains_[1] *= 0.8;

  935.     }

  936.     else if (instType_ == 7) { // sleighbell

  937.       gains_[3] *= 0.5;

  938.       gains_[4] *= 0.3;

  939.     }

  940.     else if (instType_ == 12) { // cokecan

  941.       for (i=1;i<nFreqs_;i++) gains_[i] *= 1.8;

  942.     }

  943.     if (instType_ != 3 && instType_ != 10) {

  944.       // reverse calculate decay setting

  945.       double temp = (double) (64.0 * (systemDecay_-defDecays_[instType_])/(decayScale_[instType_]*(1-defDecays_[instType_])) + 64.0);

  946.       // scale gains_ by decay setting

  947.       for (i=0;i<nFreqs_;i++) gains_[i] *= ((128-temp)/100.0 + 0.36);

  948.     }

  949.   }

  950.   else if (number == __SK_ModWheel_) { // 1 ... resonance frequency

  951.     for (i=0; i<nFreqs_; i++)	{

  952.       if (instType_ == 6 || instType_ == 2 || instType_ == 7) // limit range a bit for tambourine

  953.         temp = center_freqs_[i] * pow (1.008,value-64);

  954.       else

  955.         temp = center_freqs_[i] * pow (1.015,value-64);

  956.       t_center_freqs_[i] = temp;

  957. 

  958.       coeffs_[i][0] = -resons_[i] * 2.0 * cos(temp * TWO_PI / Stk::sampleRate());

  959.       coeffs_[i][1] = resons_[i]*resons_[i];

  960.     }

  961.   }

  962.   else if (number == __SK_AfterTouch_Cont_) { // 128

  963.     shakeEnergy_ += normalizedValue * MAX_SHAKE * 0.1;

  964.     if (shakeEnergy_ > MAX_SHAKE) shakeEnergy_ = MAX_SHAKE;

  965.     if (instType_==10 || instType_==3)	{

  966. 	    ratchetPos_ = (int) fabs(value - lastRatchetPos_);

  967. 	    ratchetDelta_ = 0.0002 * ratchetPos_;

  968. 	    lastRatchetPos_ = (int) value;

  969.     }

  970.   }

  971.   else  if (number == __SK_ShakerInst_) { // 1071

  972.     instType_ = (int) (value + 0.5);	//  Just to be safe

  973.     this->setupNum(instType_);

  974.   }

  975. #if defined(_STK_DEBUG_)

  976.   else {

  977.     oStream_ << "Shakers::controlChange: undefined control number (" << number << ")!";

  978.     handleError( StkError::WARNING );

  979.   }

  980. #endif

  981. }

  982. 

  983. // KLUDGE-O-MATIC-O-RAMA

  984. 

  985. StkFloat Shakers :: wuter_tick( void ) {

  986.   StkFloat data;

  987.   int j;

  988.   shakeEnergy_ *= systemDecay_;               // Exponential system decay

  989.   if (my_random(32767) < nObjects_) {     

  990.     sndLevel_ = shakeEnergy_;   

  991.     j = my_random(3);

  992. 	  if (j == 0)   {

  993.       center_freqs_[0] = WUTR_CENTER_FREQ1 * (0.75 + (0.25 * noise_tick()));

  994. 	    gains_[0] = fabs(noise_tick());

  995. 	  }

  996. 	  else if (j == 1)      {

  997.       center_freqs_[1] = WUTR_CENTER_FREQ1 * (1.0 + (0.25 * noise_tick()));

  998. 	    gains_[1] = fabs(noise_tick());

  999. 	  }

  1000. 	  else  {

  1001.       center_freqs_[2] = WUTR_CENTER_FREQ1 * (1.25 + (0.25 * noise_tick()));

  1002. 	    gains_[2] = fabs(noise_tick());

  1003. 	  }

  1004. 	}

  1005. 	

  1006.   gains_[0] *= resons_[0];

  1007.   if (gains_[0] >  0.001) {

  1008.     center_freqs_[0]  *= WUTR_FREQ_SWEEP;

  1009.     coeffs_[0][0] = -resons_[0] * 2.0 * 

  1010.       cos(center_freqs_[0] * TWO_PI / Stk::sampleRate());

  1011.   }

  1012.   gains_[1] *= resons_[1];

  1013.   if (gains_[1] > 0.001) {

  1014.     center_freqs_[1] *= WUTR_FREQ_SWEEP;

  1015.     coeffs_[1][0] = -resons_[1] * 2.0 * 

  1016.       cos(center_freqs_[1] * TWO_PI / Stk::sampleRate());

  1017.   }

  1018.   gains_[2] *= resons_[2];

  1019.   if (gains_[2] > 0.001) {

  1020.     center_freqs_[2] *= WUTR_FREQ_SWEEP;

  1021.     coeffs_[2][0] = -resons_[2] * 2.0 * 

  1022.       cos(center_freqs_[2] * TWO_PI / Stk::sampleRate());

  1023.   }

  1024. 	

  1025.   sndLevel_ *= soundDecay_;        // Each (all) event(s) 

  1026.                                    // decay(s) exponentially 

  1027.   inputs_[0] = sndLevel_;

  1028.   inputs_[0] *= noise_tick();     // Actual Sound is Random

  1029.   inputs_[1] = inputs_[0] * gains_[1];

  1030.   inputs_[2] = inputs_[0] * gains_[2];

  1031.   inputs_[0] *= gains_[0];

  1032.   inputs_[0] -= outputs_[0][0]*coeffs_[0][0];

  1033.   inputs_[0] -= outputs_[0][1]*coeffs_[0][1];

  1034.   outputs_[0][1] = outputs_[0][0];

  1035.   outputs_[0][0] = inputs_[0];

  1036.   data = gains_[0]*outputs_[0][0];

  1037.   inputs_[1] -= outputs_[1][0]*coeffs_[1][0];

  1038.   inputs_[1] -= outputs_[1][1]*coeffs_[1][1];

  1039.   outputs_[1][1] = outputs_[1][0];

  1040.   outputs_[1][0] = inputs_[1];

  1041.   data += gains_[1]*outputs_[1][0];

  1042.   inputs_[2] -= outputs_[2][0]*coeffs_[2][0];

  1043.   inputs_[2] -= outputs_[2][1]*coeffs_[2][1];

  1044.   outputs_[2][1] = outputs_[2][0];

  1045.   outputs_[2][0] = inputs_[2];

  1046.   data += gains_[2]*outputs_[2][0];

  1047.  

  1048.   finalZ_[2] = finalZ_[1];

  1049.   finalZ_[1] = finalZ_[0];

  1050.   finalZ_[0] = data * 4;

  1051. 

  1052.   data = finalZ_[2] - finalZ_[0];

  1053.   return data;

  1054. }

  1055. 

  1056. StkFloat Shakers :: ratchet_tick( void ) {

  1057.   StkFloat data;

  1058.   if (my_random(1024) < nObjects_) {

  1059.     sndLevel_ += 512 * ratchet_ * totalEnergy_;

  1060.   }

  1061.   inputs_[0] = sndLevel_;

  1062.   inputs_[0] *= noise_tick() * ratchet_;

  1063.   sndLevel_ *= soundDecay_;

  1064. 		 

  1065.   inputs_[1] = inputs_[0];

  1066.   inputs_[0] -= outputs_[0][0]*coeffs_[0][0];

  1067.   inputs_[0] -= outputs_[0][1]*coeffs_[0][1];

  1068.   outputs_[0][1] = outputs_[0][0];

  1069.   outputs_[0][0] = inputs_[0];

  1070.   inputs_[1] -= outputs_[1][0]*coeffs_[1][0];

  1071.   inputs_[1] -= outputs_[1][1]*coeffs_[1][1];

  1072.   outputs_[1][1] = outputs_[1][0];

  1073.   outputs_[1][0] = inputs_[1];

  1074.      

  1075.   finalZ_[2] = finalZ_[1];

  1076.   finalZ_[1] = finalZ_[0];

  1077.   finalZ_[0] = gains_[0]*outputs_[0][1] + gains_[1]*outputs_[1][1];

  1078.   data = finalZ_[0] - finalZ_[2];

  1079.   return data;

  1080. }

  1081. 

  1082. StkFloat Shakers :: tbamb_tick( void ) {

  1083.   StkFloat data, temp;

  1084.   static int which = 0;

  1085.   int i;

  1086. 

  1087.   if (shakeEnergy_ > MIN_ENERGY)	{

  1088.       shakeEnergy_ *= systemDecay_;    // Exponential system decay

  1089.       if (float_random(1024.0) < nObjects_) {

  1090. 	    sndLevel_ += shakeEnergy_;

  1091. 	    which = my_random(7);

  1092. 	  }  

  1093.       temp = sndLevel_ * noise_tick();      // Actual Sound is Random

  1094. 	  for (i=0;i<nFreqs_;i++)	inputs_[i] = 0;

  1095. 	  inputs_[which] = temp;

  1096.       sndLevel_ *= soundDecay_;                   // Exponential Sound decay 

  1097.       finalZ_[2] = finalZ_[1];

  1098.       finalZ_[1] = finalZ_[0];

  1099.       finalZ_[0] = 0;

  1100.       for (i=0;i<nFreqs_;i++)	{

  1101.         inputs_[i] -= outputs_[i][0]*coeffs_[i][0];  // Do

  1102.         inputs_[i] -= outputs_[i][1]*coeffs_[i][1];  // resonant

  1103.         outputs_[i][1] = outputs_[i][0];            // filter

  1104.         outputs_[i][0] = inputs_[i];                // calculations

  1105.         finalZ_[0] += gains_[i] * outputs_[i][1];

  1106.       }

  1107.       data = finalZCoeffs_[0] * finalZ_[0];     // Extra zero(s) for shape

  1108.       data += finalZCoeffs_[1] * finalZ_[1];    // Extra zero(s) for shape

  1109.       data += finalZCoeffs_[2] * finalZ_[2];    // Extra zero(s) for shape

  1110.       if (data > 10000.0)	data = 10000.0;

  1111.       if (data < -10000.0) data = -10000.0;

  1112.       data = data * 0.0001;

  1113.   }

  1114.   else data = 0.0;

  1115.   return data;

  1116. }

  1117. 

  1118. } // stk namespace