├── README.md
├── algos.js
├── fieldsos.css
├── index.html
├── patches.js
└── util.js


/README.md:
--------------------------------------------------------------------------------
1 | # FieldsOS
2 | 
3 | Recreating my FieldsOS electronic music system for the web.
4 | 
5 | Latest version deployed here: https://williamfields.com/fieldsos
6 | 


--------------------------------------------------------------------------------
/algos.js:
--------------------------------------------------------------------------------
  1 | 
  2 | function algoRandom()
  3 | {
  4 |     if (bdSelected)
  5 |     {       
  6 |         bd.decay = randInt(1,100);
  7 |         bd.density = randInt(0,100);
  8 |         bd.frequency = randInt(20,200); 
  9 |         bd.multi = randInt(1,16);
 10 |         bd.octaves = randInt(0,8);
 11 |         bd.pitchDecay = randInt(0,100);
 12 |         bd.random = randInt(0,100);
 13 |         bd.seq = getTunedSequence();
 14 |         bd.steps = randInt(1,16);
 15 |     }
 16 | 
 17 |     if (hatSelected)
 18 |     {
 19 |         hat.decay = randInt(1,100);
 20 |         hat.density = randInt(0,100);
 21 |         hat.frequency = randInt(0,10000);
 22 |         hat.harmonicity = randInt(0,128); 
 23 |         hat.modulationIndex = randInt(0,256);
 24 |         hat.multi = randInt(1,16);
 25 |         hat.random = randInt(0,100);
 26 |         hat.resonance = randInt(0,10000);
 27 |         hat.seq = getTunedSequence();
 28 |         hat.steps = randInt(1,16);
 29 |     }
 30 | 
 31 |     if (snrSelected)
 32 |     {        
 33 |         snr.decay = randInt(1,100);
 34 |         snr.density = randInt(0,100);
 35 |         snr.frequency = 100+Math.pow(Math.random(),2)*1000;    
 36 |         snr.multi = randInt(1,16);
 37 |         snr.octaves = Math.pow(Math.random(),2)*8;
 38 |         snr.pitchDecay = randInt(0,100);
 39 |         snr.random = randInt(0,100);
 40 |         snr.seq = getTunedSequence();
 41 |         snr.steps = randInt(1,16);
 42 |         if (probDo(0.33))
 43 |         {
 44 |             snr.noiseType = "white";
 45 |         }
 46 |         else
 47 |         {
 48 |             if (probDo(0.5))
 49 |             {
 50 |                 snr.noiseType = "pink";
 51 |             }
 52 |             else
 53 |             {
 54 |                 snr.noiseType = "brown";
 55 |             }
 56 |         }                                
 57 |     }
 58 | }
 59 | 
 60 | 
 61 | function algoHiphop()
 62 | {
 63 |     algoRandom();
 64 | 
 65 |     if (bdSelected)
 66 |     {
 67 |         for (var i=0;i<16;i++)
 68 |         {
 69 |             bd.seq[i] = probDo(0.25) ? rand() : 0;
 70 |         }		
 71 |         bd.seq[0] = 1;
 72 |         bd.decay = Math.pow(Math.random(),0.5)*100;
 73 |         bd.density = 100;
 74 |         bd.frequency = randInt(20,100); 
 75 |         bd.multi = 8;
 76 |         bd.octaves = randInt(0,4);
 77 |         bd.pitchDecay = randInt(0,100);
 78 |         bd.random = randInt(0,25);
 79 |         bd.steps = 16;            
 80 |     }
 81 | 
 82 |     if (hatSelected)
 83 |     {
 84 |         hat.decay = Math.pow(Math.random(),2)*100;
 85 |         hat.density = 100;
 86 |         hat.multi = probDo(0.5) ? 4 : 8;
 87 |         if (probDo(0.25)) // Sometimes do triplet hats
 88 |         {
 89 |             hat.multi = 12;
 90 |         }            
 91 |         hat.random = randInt(0,25);
 92 |         hat.steps = 16;
 93 |         if (probDo(0.5))  // Constant hi-hats
 94 |         {
 95 |             hat.steps = 1;			
 96 |             hat.seq[0] = 1;
 97 |         }
 98 |     }
 99 |     
100 |     if (snrSelected)
101 |     {
102 |         for (var i=0;i<16;i++)  // SNR always on the 2 and 4
103 |         {
104 |             snr.seq[i] = probDo(0.25) ? Math.pow(rand(),2) : 0;
105 |         }		
106 |         snr.seq[4] = 1;
107 |         snr.seq[12] = 1;
108 |         snr.decay = Math.pow(Math.random(),0.5)*100;
109 |         snr.density = 100;
110 |         snr.multi = 8;
111 |         snr.pitchDecay = randInt(0,100);
112 |         snr.random = randInt(0,25);
113 |         snr.steps = 16;
114 |     }
115 | }
116 | 
117 | 
118 | function algoTechno()
119 | {
120 |     algoRandom();
121 | 
122 |     if (bdSelected)
123 |     {
124 |         bd.seq = [1,0,0,0, 1,0,0,0, 1,0,0,0, 1,0,0,0];
125 |         bd.steps = 16;            
126 |         bd.multi = 8;
127 |         bd.random = randInt(0,25);
128 |         bd.density = 100;
129 |         bd.pitchDecay = randInt(0,100);
130 |     }
131 | 
132 |     if (hatSelected)
133 |     {
134 |         hat.steps = 16;    
135 |         if (probDo(0.5))  // Constant hi-hats
136 |         {
137 |             hat.steps = 1;			
138 |             hat.seq[0] = 1;
139 |         }
140 |         hat.multi = probDo(0.5) ? 4 : 8;
141 |         hat.density = 100;
142 |         hat.random = randInt(0,25);
143 |     }
144 | 
145 |     if (snrSelected)
146 |     {
147 |         snr.pitchDecay = randInt(0,100);     
148 |         snr.steps = 16;        
149 |         snr.multi = probDo(0.5) ? 4 : 8;
150 |         snr.density = 100;    
151 |         snr.random = randInt(0,25);
152 |     }
153 | }


--------------------------------------------------------------------------------
/fieldsos.css:
--------------------------------------------------------------------------------
  1 | :root {
  2 |     --bgcolor: rgb(135, 158, 187);
  3 |   }
  4 | 
  5 | body {
  6 |     background-color: var(--bgcolor);
  7 |     font-size: 1.5em;
  8 |     font-family: monospace;
  9 |     overflow-x: hidden;
 10 | }
 11 | 
 12 | .container {
 13 |     position: absolute;
 14 |     top: 50%;
 15 |     transform: translate(-50%, -50%);
 16 |     left: 50%;
 17 |     width: 100%;
 18 |     text-align: center;
 19 |     max-width: 500px;    
 20 | }
 21 | 
 22 | .buttonContainer { 
 23 |     margin: 25px;
 24 |     white-space: nowrap;
 25 | }
 26 | 
 27 | 
 28 | .algoSelector {
 29 |     font-family: monospace;
 30 |     font-size: 1em;
 31 |     margin:10px;
 32 |     background-color: rgba(0, 0, 0, 0);
 33 |     border: 2px solid black;
 34 |     padding:5px; 
 35 | }
 36 | 
 37 | .valueDisplay {
 38 |     display: inline-block;
 39 |     width: 40px;
 40 |     margin-left: 10px;    
 41 | }
 42 | 
 43 | .sliderContainer {
 44 |     margin-top: 25px;
 45 |     white-space: nowrap;
 46 | }
 47 | 
 48 | .slider {
 49 |     width: 100%;
 50 |     max-width:50%;        
 51 | }
 52 | 
 53 | input[type=range] {
 54 |     height: 1em;
 55 |     appearance: none;
 56 | }
 57 | 
 58 | input[type=range]:focus {
 59 |     outline: none;
 60 | }
 61 | 
 62 | input[type=range]::-webkit-slider-thumb {
 63 |     height: 25px;
 64 |     width: 15px;
 65 |     background: black;
 66 |     appearance: none;
 67 |   }
 68 | 
 69 |   input[type=range]::-webkit-slider-runnable-track {
 70 |     background: var(--bgcolor);
 71 |     border: 2px solid #000000;
 72 |   }
 73 | 
 74 | .sliderLabel {
 75 |     width: 100px;
 76 |     text-align:right;
 77 |     float:left;
 78 |     margin-right: 10px;
 79 | }
 80 | 
 81 | 
 82 | 
 83 | .controlButton {
 84 |     font-family:monospace;
 85 |     font-size: 50px;
 86 |     background-color: rgba(0, 0, 0, 0);
 87 |     margin: 0px 10px;
 88 |     padding: 10px 25px;
 89 | }
 90 | 
 91 | .checkboxContainer {
 92 |     width: 390px;
 93 |     margin: 50px 100px;
 94 |     text-align: center;
 95 | }
 96 | 
 97 | /* Customize the label (the container) */
 98 | .checkbox {
 99 |     display: block;
100 |     position: relative;
101 |     float: left;
102 |     padding-left: 70px;
103 |     text-align:left;    
104 |     cursor: pointer;    
105 |     width:60px;
106 |     -webkit-user-select: none;
107 |     -moz-user-select: none;
108 |     -ms-user-select: none;
109 |     user-select: none;
110 |   }
111 |   
112 |   /* Hide the browser's default checkbox */
113 |   .checkbox input {
114 |     position: absolute;
115 |     opacity: 0;
116 |     cursor: pointer;
117 |     height: 0;
118 |     width: 0;
119 |   }
120 |     
121 |   /* Create a custom checkbox */
122 |   .checkmark {
123 |     position: absolute;
124 |     top: 0;
125 |     left: 0;
126 |     height: 50px;
127 |     width: 50px;
128 |     background-color: rgba(0, 0, 0, 0);
129 |     border: 2px solid black;
130 |   }
131 |   
132 |   /* When the checkbox is checked, add a black background */
133 |   .checkbox input:checked ~ .checkmark {
134 |     background-color: black;
135 |   }
136 |   
137 |   .checkboxLabel
138 |   {
139 |     margin-top:15px;    
140 |   }
141 | 
142 | 
143 |   .disable-select{
144 |     user-select:none;
145 |     -moz-user-select:none;
146 |     -webkit-user-select:none;
147 |     -webkit-touch-callout:none;
148 |     -ms-user-select:none;
149 |   }
150 | 
151 | 
152 | 
153 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | 
  3 | <html>
  4 |     <head>
  5 |     <meta charset="utf-8">
  6 |         <title>FieldsOS</title>
  7 |         <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  8 |         <script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.48/Tone.js"></script>
  9 |         <link rel="stylesheet" href="fieldsos.css?v=7">
 10 |     </head>
 11 | 
 12 |     <body>
 13 | 
 14 |         <div class="container">
 15 |             <b>FieldsOS</b> v0.2
 16 |             <div class="buttonContainer">
 17 |                 <button id="b" class="controlButton" onClick="go();">&gt;</button>
 18 |                 <button id="regenButton" class="controlButton" onClick="regen();">?</button>
 19 |             </div>
 20 | 
 21 |             Algorithm:
 22 |             <select class="algoSelector" onChange="algo = this.options[this.selectedIndex].value;">
 23 |                 <option value="random">Random</option>
 24 |                 <option value="hiphop">Hiphop</option>
 25 |                 <option value="techno">Techno</option>
 26 |             </select>
 27 | 
 28 |             <script type="text/javascript">
 29 | 
 30 |                 var sliders = [
 31 |                     { name: "tempo",        label:"TEMPO",      min: 1,     max: 200,   default: 120,       },
 32 |                     { name: "steps",        label:"STEPS",      min: 1,     max: 16,    default: 16,        },
 33 |                     { name: "multi",        label:"MULTI",      min: 1,     max: 16,    default: 8,         },
 34 |                     { name: "random",       label:"RANDOM",     min: 0,     max: 100,   default: 0,         },
 35 |                     { name: "density",      label:"DENSITY",    min: 0,     max: 100,   default: 100,       },
 36 |                     { name: "decay",        label:"DECAY",      min: 1,     max: 100,   default: 50,        },
 37 |                     { name: "frequency",    label:"FREQ",       min: 20,    max: 1000,  default: 500,       },
 38 |                     { name: "octaves",      label:"FREQDROP",   min: 0,     max: 8,     default: 2,         },
 39 |                     { name: "pitchDecay",   label:"DROPTIME",   min: 0,     max: 100,   default: 25,       },
 40 |                 ];
 41 |     
 42 |                 for (var i=0; i<sliders.length; i++)
 43 |                 {
 44 |                     document.write("<div class='sliderContainer'>");                    
 45 |                     document.write("<div class='sliderLabel'>"+sliders[i].label+"</div>");
 46 |                     document.write("<input type=\"range\" class=\"slider\" min=\""+sliders[i].min+"\" max=\""+sliders[i].max+"\" value=\""+sliders[i].default+"\" oninput=\"sliderChanged('"+sliders[i].name+"',this.value);\"><span id=\""+sliders[i].name+"Display\" class=\"valueDisplay\">"+sliders[i].default+"</span>");
 47 |                     document.write("</div>");
 48 |                 }
 49 |             </script>
 50 | 
 51 |             <div class="checkboxContainer">
 52 |                 <label class="checkbox">
 53 |                     <input type="checkbox" id="bdSelector" checked="checked" onchange="bdSelected=this.checked;">
 54 |                     <span class="checkmark"></span>
 55 |                     <div class="checkboxLabel">BD</div>
 56 |                 </label>
 57 |                 <label class="checkbox">
 58 |                     <input type="checkbox" id="hatSelector" checked="checked" onchange="hatSelected=this.checked;">
 59 |                     <span class="checkmark"></span>
 60 |                     <div class="checkboxLabel">HAT</div>
 61 |                 </label>
 62 |                 <label class="checkbox">
 63 |                     <input type="checkbox" id="snrSelector" checked="checked" onchange="snrSelected=this.checked;">
 64 |                     <span class="checkmark"></span>
 65 |                     <div class="checkboxLabel">SNR</div>
 66 |                 </label>
 67 | 
 68 |             </div>
 69 |         </div>
 70 | 
 71 |         <script type="text/javascript" src="util.js?v=7"></script>
 72 |         <script type="text/javascript" src="patches.js?v=7"></script>
 73 |         <script type="text/javascript" src="algos.js?v=7"></script>
 74 |         <script type="text/javascript">
 75 | 
 76 |             // ------------------------------------------------
 77 |             // CONTROLS
 78 |             // ------------------------------------------------
 79 | 
 80 |             var playing = false;
 81 |             var tempo = 120;
 82 |             var bdSelected = true;
 83 |             var hatSelected = true;
 84 |             var snrSelected = true;
 85 |             var algo = "random";
 86 |             
 87 |             function go()
 88 |             {
 89 |                 if (!playing)
 90 |                 {
 91 |                     play();
 92 |                     playing = true;
 93 |                     document.getElementById("b").innerHTML = '=';
 94 |                 }                
 95 |                 else
 96 |                 {
 97 |                     stop();
 98 |                     playing = false;
 99 |                     document.getElementById("b").innerHTML = '&gt';
100 |                 }                
101 |             }
102 | 
103 |             function stop()
104 |             {
105 |                 loop.stop();
106 |                 Tone.Transport.stop();  
107 |             }
108 | 
109 |             function play()
110 |             {                        
111 |                 counter = 0;
112 |                 Tone.Transport.start();                        
113 |                 loop.start(0);
114 |             }
115 | 
116 |             function regen()
117 |             {
118 |                 document.getElementById("regenButton").innerHTML = "!";
119 |                 setTimeout(()=>{
120 |                     document.getElementById("regenButton").innerHTML = "?";
121 |                 },100);
122 | 
123 |                 switch (algo)
124 |                 {
125 |                     case "random": algoRandom(); break;
126 |                     case "hiphop": algoHiphop(); break;
127 |                     case "techno": algoTechno(); break;
128 |                 }
129 |                 
130 |                 bd.update();
131 |                 hat.update();
132 |                 snr.update();
133 |             }
134 | 
135 |             function sliderChanged(sliderName, value)
136 |             {
137 |                 // Special cases
138 |                 if (sliderName == "tempo")
139 |                 {
140 |                     document.getElementById('tempoDisplay').innerHTML=value;
141 |                     Tone.Transport.bpm.value=tempo=value;
142 |                 }
143 |                 else
144 |                 {
145 |                     document.getElementById(sliderName+'Display').innerHTML=value;
146 |                     if (bdSelected && typeof bd[sliderName] !== "undefined")
147 |                     {
148 |                         bd[sliderName]=value;
149 |                         bd.update();
150 |                     }
151 |                     if (hatSelected && typeof hat[sliderName] !== "undefined")
152 |                     {
153 |                         hat[sliderName]=value;
154 |                         hat.update();
155 |                     }                    
156 |                     if (snrSelected && typeof snr[sliderName] !== "undefined") 
157 |                     {
158 |                         snr[sliderName]=value;
159 |                         snr.update();
160 |                     }
161 |                 }
162 |             }
163 | 
164 |             // ------------------------------------------------
165 |             // FX
166 |             // ------------------------------------------------
167 |             
168 |             const reverb = new Tone.Freeverb({
169 |                 roomSize: 0.1,
170 |                 //dampening: 4000,
171 |                 wet: 0.1
172 |             }).toDestination();
173 |         
174 |             
175 |             // ------------------------------------------------
176 |             // SYNTHS
177 |             // ------------------------------------------------
178 | 
179 |             var bd = new BdPatch(reverb);
180 |             var hat = new HatPatch(reverb); 
181 |             var snr = new SnrPatch(reverb);
182 | 
183 | 
184 |             // ------------------------------------------------
185 |             // SEQUENCING
186 |             // ------------------------------------------------
187 |             
188 |             const loop = new Tone.Loop((time) => {
189 |              
190 | 
191 |                 executeSequence(bd, time);
192 |                 executeSequence(hat, time);
193 |                 executeSequence(snr, time);
194 | 
195 |                 counter++;
196 | 
197 |             }, "64n");
198 |     
199 |             function executeSequence(obj, time)
200 |             {
201 |                 if (obj.steps == 1)  // Special case when step count is 1
202 |                 {
203 |                     obj.seqPos = Math.floor((counter/32)*obj.multi) % 2; // Pretend there are two steps
204 |                     seqPosEffective = 0;                              // But always use the first value
205 |                 }
206 |                 else
207 |                 {
208 |                     obj.seqPos = Math.floor((counter/32)*obj.multi) % obj.steps;
209 |                     seqPosEffective = obj.seqPos;
210 |                 }            
211 |                 if (obj.seqPos != obj.seqPosPrev)
212 |                 {                   
213 |                     if (probDo(obj.density/100))
214 |                     {
215 |                         if (obj.seq[seqPosEffective] > 0) // If something scheduled, do it
216 |                         {
217 |                             obj.trigger(time, obj.seq[seqPosEffective]);
218 |                         }
219 |                         else if (probDo(obj.random/100))  // otherwise, sometimes do something random
220 |                         {
221 |                             if (probDo(0.5))
222 |                             {
223 |                                 obj.trigger(time, 1);  // Full velocity trigger
224 |                             }
225 |                             else
226 |                             {                            
227 |                                 obj.trigger(time, 0.75);  // Quiet trigger
228 |                                                             
229 |                                 // Roll
230 |                                 /*
231 |                                 obj.trigger(time, 1);
232 |                                 obj.trigger(time + (6/tempo)*1, 0.75);
233 |                                 obj.trigger(time + (6/tempo)*2, 0.5);
234 |                                 obj.trigger(time + (6/tempo)*3., 0.75);
235 |                                 obj.trigger(time + (6/tempo)*4, 1);
236 |                                 */
237 |                             }
238 |                         }
239 |                     }
240 |                 }
241 |                 obj.seqPosPrev = obj.seqPos;
242 |             }
243 | 
244 |         </script>
245 |     </body>
246 | 
247 | </html>
248 | 


--------------------------------------------------------------------------------
/patches.js:
--------------------------------------------------------------------------------
  1 | 
  2 | VELOCITY_RESPONSE_CURVE = 2;
  3 | 
  4 | class Patch
  5 | {
  6 |     decay;
  7 |     seq;
  8 |     steps;
  9 |     multi;
 10 |     seqPos;
 11 |     seqPosPrev;
 12 |     density;        
 13 |     random;
 14 | 
 15 |     constructor()
 16 |     {
 17 |         this.seq = [];                
 18 |         this.decay = 50;
 19 |         this.steps = 16;
 20 |         this.seqPos = 0;
 21 |         this.seqPosPrev = -1;
 22 |         this.multi = 8;
 23 |         this.density = 100;      
 24 |         this.random = 0;
 25 |     }
 26 | }
 27 | 
 28 | class BdPatch extends Patch
 29 | {
 30 |     bdSynth;
 31 |     octaves;    
 32 |     frequency;
 33 |     pitchDecay;
 34 | 
 35 |     constructor(output)
 36 |     {                
 37 |         super();
 38 |         this.seq = [1,0,0,0, 0,0,0,0, 1,0,0,0, 0,0,0,0];
 39 |         this.frequency = 50;
 40 |         this.octaves = 4;
 41 |         this.pitchDecay = 26;
 42 |         this.bdSynth = new Tone.MembraneSynth().connect(output);
 43 |         this.update();                                            
 44 |     }
 45 | 
 46 |     trigger(time,vel)
 47 |     {
 48 |         vel = Math.pow(vel,VELOCITY_RESPONSE_CURVE);
 49 |         this.bdSynth.triggerAttackRelease(this.frequency, "16n", time, vel);
 50 |     }
 51 | 
 52 |     update()
 53 |     {
 54 |         this.bdSynth.set({
 55 |             volume: 0,
 56 |             octaves: this.octaves,
 57 |             pitchDecay: this.pitchDecay/100,
 58 |             envelope: {                        
 59 |                 decay: Math.pow((this.decay/100),3),
 60 |                 release: (this.decay/100)*10
 61 |             }
 62 |         });
 63 |     }
 64 | }
 65 | 
 66 | 
 67 | class HatPatch extends Patch
 68 | {
 69 |     hatSynth;
 70 |     harmonicity;
 71 |     resonance;
 72 |     modulationIndex;
 73 |     frequency;
 74 | 
 75 |     constructor(output)
 76 |     {           
 77 |         super();     
 78 |         this.seq = [1,0,1,0, 1,0,1,0, 1,0,1,0, 1,0,1,0];
 79 |         this.harmonicity = 4; 
 80 |         this.resonance = 1000;
 81 |         this.modulationIndex = 32;
 82 |         this.frequency = 1000;
 83 |         this.hatSynth = new Tone.MetalSynth().connect(output);
 84 |         this.update();
 85 |     }
 86 | 
 87 |     trigger(time,vel)
 88 |     {
 89 |         vel = Math.pow(vel,VELOCITY_RESPONSE_CURVE);
 90 |         this.hatSynth.triggerAttackRelease("C4", "32n", time, vel);  // TODO: How do note and frequency interact?
 91 |     }
 92 | 
 93 |     update()
 94 |     {
 95 |         this.hatSynth.set({
 96 |             volume: -12,
 97 |             harmonicity: this.harmonicity,
 98 |             resonance: this.resonance,
 99 |             modulationIndex: this.modulationIndex,
100 |             frequency: this.frequency,
101 |             envelope: {
102 |                 decay: Math.pow((this.decay/100),3),
103 |                 release: (this.decay/100)*10
104 |             }
105 |         });
106 |     }
107 | }
108 | 
109 | 
110 | class SnrPatch extends Patch
111 | {
112 |     snrNoiseSynth;
113 |     snrToneSynth;
114 |     octaves;
115 |     frequency;
116 |     noiseType;
117 |     pitchDecay;
118 | 
119 |     constructor(output)
120 |     {           
121 |         super();
122 |         this.seq = [0,0,0,0, 1,0,0,0, 0,0,0,0, 1,0,0,0];
123 |         this.frequency = 200;
124 |         this.octaves = 2;
125 |         this.noiseType = "white";
126 |         this.snrNoiseSynth = new Tone.NoiseSynth().connect(output);
127 |         this.snrToneSynth = new Tone.MembraneSynth().connect(output);
128 |         this.pitchDecay = 25;
129 |         this.update();
130 |     }
131 | 
132 |     trigger(time,vel)
133 |     {
134 |         vel = Math.pow(vel,VELOCITY_RESPONSE_CURVE);
135 |         this.snrNoiseSynth.triggerAttackRelease("64n", time, vel); 
136 |         this.snrToneSynth.triggerAttackRelease(this.frequency, "64n", time, vel);      
137 |     }
138 | 
139 |     update()
140 |     {
141 |         this.snrNoiseSynth.set({
142 |             volume: 0,
143 |             noise: {
144 |                 type: this.noiseType
145 |             },
146 |             envelope: {
147 |                 decay: Math.pow((this.decay/100),2)*0.1,
148 |                 release: (this.decay/100)*10
149 |             }
150 |         });
151 |         this.snrToneSynth.set({
152 |             volume: -6,
153 |             octaves: this.octaves,
154 |             pitchDecay: this.pitchDecay/100,
155 |             envelope: {
156 |                 decay: Math.pow((this.decay/100),4)*0.1,
157 |                 release: (this.decay/100)*5
158 |             }
159 |         });
160 |     }
161 | }


--------------------------------------------------------------------------------
/util.js:
--------------------------------------------------------------------------------
 1 | 
 2 | function rand(min, max) 
 3 | {	
 4 |     if (typeof min === "undefined" || typeof max === "undefined")
 5 |     {
 6 |         min = 0;
 7 |         max = 1;
 8 |     }
 9 | 
10 |     return Math.random() * (max - min) + min;	
11 | }
12 | 
13 | function randInt(min, max) {
14 |     return Math.floor(Math.random() * (max - min + 1)) + min;
15 | }
16 | 
17 | function probDo(x) 
18 | {
19 |     return Math.random() < x;
20 | }
21 | 
22 | function getTunedSequence(steps=16)
23 | {
24 |     var seq = [];
25 |     for (var i=0;i<steps;i++)
26 |     {
27 |         var f = 0;
28 |         var r = rand();
29 |         if (r < 0.1)
30 |         {
31 |             f = 1;
32 |         }
33 |         else if (r < 0.8)
34 |         {
35 |             f = 0;
36 |         }
37 |         else
38 |         {
39 |             f = rand();
40 |         }
41 |         seq[i] = f;
42 |     }
43 |     return seq;
44 | }


--------------------------------------------------------------------------------