Fixed LFO mappings.

Author: looshi2

src/audio/LFO.js

@@ -7,10 +7,6 @@ for affecting gain values, mulitiplier should be quite small, around .001.
 let lfo = new LFO(options)
 let multiplier = 0.001
 lfo.connect(node.audioParam, multiplier)
-
-When the LFO is connected to the filter, clicking can be heard if the LFO
-gain is greater than the current filter frequency.  I don't know how to
-adjust the LFO gain automatically in accordance with the filter.
 */
 
 export default class LFO {
@@ -43,12 +39,9 @@ export default class LFO {
     this.updateShape(shape)
   }
 
-  connect (destination, multiplier, persist = false) {
+  connect (destination, multiplier) {
     this.lfoGain.gain.value = this._value * multiplier
     this.multiplier = multiplier
-    if (!persist) {
-      this.init(this.lfo.frequency.value, this._shape, this.lfoGain.gain.value)
-    }
     this.lfoGain.connect(destination)
   }
 

src/audio/Oscillator.js

@@ -10,40 +10,49 @@ export default class Oscillator {
     this._detune = props.detune
     this._octave = props.octave
     this._note = props._note
-    this._lfoPitch = null
-    this._persistLFO = false
-    this._lfoAmount = null
     this._glide = Number(props.glide) / 100
 
+    // LFOs attached to this oscillator.
+    this.pitchLFOs = []
+    this.amountLFOs = []
+
     this.output = props.output
     this.audioContext = props.audioContext
 
     this.gainNode = props.audioContext.createGain()
     this.gainNode.connect(this.output)
   }
 
-  // Will connect immediately, but later on if the waveform is loaded
-  // it will connect again below.
-  // Only one LFO can be set on page load, however multiple LFOs can be
-  // set after page load.  TODO : allow multiple on page load.
-  // 'persist' parameter fixes an issue in setting LFO from filter to volume -
-  // Very loud pops happen when a note is on and setting lfo to volume.
   connectPitchToLFO (lfo, persist = false) {
-    this._lfoPitch = lfo
-    this._persistLFO = persist
     if (this.wavSource) {
-      this._lfoPitch.connect(this.wavSource.detune, 10, persist)
+      // Connect now if wave is loaded.
+      lfo.connect(this.wavSource.detune, 10, persist)
     }
+    this.pitchLFOs.push(lfo)
+  }
+
+  disconnectPitchFromLFO (lfo) {
+    lfo.disconnect()
+    this.pitchLFOs = this.pitchLFOs.filter((_lfo) => {
+      return _lfo.id !== lfo.id
+    })
   }
 
-  connectAmountToLFO (lfo, persist = false) {
-    this._lfoAmount = lfo
-    this._persistLFO = persist
+  connectAmountToLFO (lfo) {
+    this.amountLFOs.push(lfo)
     if (this.wavSource) {
-      this._lfoAmount.connect(this.gainNode.gain, 0.01, persist)
+      // Connect now if wave is loaded.
+      lfo.connect(this.gainNode.gain, 0.01)
     }
   }
 
+  disconnectAmountFromLFO (lfo) {
+    lfo.disconnect()
+    this.amountLFOs = this.amountLFOs.filter((_lfo) => {
+      return _lfo.id !== lfo.id
+    })
+  }
+
   // Limits gain between zero and 1.
   set amount (val) {
     this.gainNode.gain.value = limit(0, 1, val / 100)
@@ -128,12 +137,14 @@ export default class Oscillator {
     this.wavSource._started = true
     this.wavSource.connect(this.gainNode)
 
-    if (this._lfoPitch) {
-      this._lfoPitch.connect(this.wavSource.detune, 10, this._persistLFO)
-    }
-    if (this._lfoAmount) {
-      this._lfoAmount.connect(this.gainNode.gain, 0.01)
-    }
+    // Reconnect lfos to the new wavSource instance (if any were connected).
+    this.pitchLFOs.forEach((lfo) => {
+      lfo.connect(this.wavSource.detune, 10)
+    })
+    this.amountLFOs.forEach((lfo) => {
+      lfo.connect(this.gainNode.gain, 0.01, 10)
+    })
+
     this.updatePitch()
   }
 

src/audio/Synth.js

@@ -160,17 +160,28 @@ class Synth extends React.Component {
   // Route LFOs to targets.
   routeLFO (lfo, destination) {
     lfo.disconnect()
+    // Disconnect the LFO from any oscillators ( if it was set to any ).
+    this.oscillators.map((osc) => {
+      osc.disconnectPitchFromLFO(lfo)
+      osc.disconnectAmountFromLFO(lfo)
+    })
+
     let id = destination.moduleId
 
+    // LFO to Amp.
     if (id === 'amp') {
       lfo.connect(this.oscillatorsBus.gain, 0.04)
     }
+
+    // LFO to Filter.
     if (id === 'filter') {
       // Have to do this for each filter instance.
       this.biquadFilter.filters.forEach((filter) => {
-        lfo.connect(filter.detune, 50, true)
+        lfo.connect(filter.detune, 50)
       })
     }
+
+    // LFO to oscillator detune and amount.
     if (id === 'oscAll') {
       this.oscillators.map((osc) => {
         osc.connectPitchToLFO(lfo, true)
@@ -185,18 +196,19 @@ class Synth extends React.Component {
       }
     }
 
-    if (id === 'chorus') {
-      if (destination.property === 'time') {
-        lfo.connect(this.chorus.lfoInputTime, 0.001)
-      } else if (destination.property === 'amount') {
-        lfo.connect(this.chorus.lfoInputAmount, 0.01)
+    // LFO to Effects.
+    if (id === 'effects') {
+      if (destination.property === 'chorusTime') {
+        lfo.connect(this.chorus.lfoInputTime, 0.01)
+      } else if (destination.property === 'chorusAmount') {
+        lfo.connect(this.chorus.lfoInputAmount, 0.05)
       }
     }
 
-    // LFO to LFO mappings.  Sort of works.
+    // LFO to LFO.
     if (id && id[0] === 'l') {
-      let targetLFO = this.LFOs.find((osc) => osc.id === id)
-      lfo.connect(targetLFO.lfoInputFrequency, 1, true)
+      let targetLFO = this.LFOs.find((l) => l.id === id)
+      lfo.connect(targetLFO.lfoInputFrequency, 1)
     }
   }