Implement ElectricSnare sound design (Midi note 40) (#78)

* Add ElectricSnare sound design and link the new sound to percupuff

* Simplify implementation of electric snare drum frequency + adjust more values

* Address PR comments: remove notch filter, tweak values, update comments

Author: rileychou

dsp/Percupuff.cmajor

@@ -30,6 +30,7 @@ namespace Percupuff
             noise = std::noise::White;
             bassDrum = Drums::BassDrum;
             snare = Drums::Snare;
+            electricSnare = Drums::ElectricSnare;
             hihat = Drums::Hihat;
             clap = Drums::Clap;
             cowbell = Drums::Cowbell;
@@ -52,12 +53,14 @@ namespace Percupuff
             p.paramsOut -> cowbell.paramsIn;
             p.paramsOut -> hihat.paramsIn;
             p.paramsOut -> snare.paramsIn;
+            p.paramsOut -> electricSnare.paramsIn;
             p.paramsOut -> sideStick.paramsIn;
 
             // Send the midi events so the sound processors know when to start playing.
             midiIn -> mpe;
             mpe -> bassDrum.eventIn;
             mpe -> snare.eventIn;
+            mpe -> electricSnare.eventIn;
             mpe -> hihat.eventIn;
             mpe -> clap.eventIn;
             mpe -> cowbell.eventIn;
@@ -70,6 +73,7 @@ namespace Percupuff
             // Some sounds use noise.
             noise -> hihat.noiseIn;
             noise -> snare.noiseIn;
+            noise -> electricSnare.noiseIn;
             noise -> clap.noiseIn;
             noise -> crash.noiseIn;
             noise -> claves.noiseIn;
@@ -78,6 +82,7 @@ namespace Percupuff
             // it into the gain limiter to adjust how loud they are.
             bassDrum -> gainLimiter;
             snare -> gainLimiter;
+            electricSnare -> gainLimiter;
             hihat -> gainLimiter;
             clap -> gainLimiter;
             cowbell -> gainLimiter;

dsp/drums/ElectricSnare.cmajor

@@ -0,0 +1,84 @@
+// Reference videos: 
+// https://www.youtube.com/watch?v=Fks15MXxwas
+// https://www.youtube.com/watch?v=NifOAvu7KQk
+
+namespace Percupuff
+{
+    namespace Drums
+    {
+        // This processor tries to create a electric snare drum sound.
+        // An oscillator with a triangle waveform is used to create the initial impact of the snare,
+        // with filtered white noise mixed in for more brightness.
+        processor ElectricSnare {
+            input event (std::notes::NoteOn) eventIn;
+            output stream float<2> out;
+            input stream float noiseIn;
+            input event Params paramsIn;
+            
+            float triggerVelocity = 0.0f;
+            int midiNotePitch = 0;
+            float outputLevel = 0.5f;
+            float panning = 0.0f;
+            float velocitySensitivity = 1.0f;
+
+            event paramsIn(Params p) {
+                midiNotePitch = int(p.snare2Midi);
+                outputLevel = p.snare2Level * 0.01f;
+                panning = p.snare2Panning;
+                velocitySensitivity = p.snare2Velocity;
+            }
+
+            event eventIn(std::notes::NoteOn n) {
+                if (int (n.pitch) == midiNotePitch) {
+                    triggerVelocity = sqrt(n.velocity);
+                }
+            }
+
+            node envelope = Envelope;
+            node osc1 = Oscillator(OscillatorShape::triangle);
+
+            // Filters that shape the white noise.
+            // Use LpfResonant to add resonance for brightness
+            LpfResonant lowpass = (0.0f, 0.0f);
+            
+            void main()
+            {
+                osc1.frequencyIn <- 160.0f;
+
+                let invSampleRate = 1.0f / float(processor.frequency);
+                
+                loop
+                {
+                    while (triggerVelocity == 0) {
+                        advance();
+                    }
+
+                    let vel = triggerVelocity;
+                    triggerVelocity = 0.0f;
+
+                    envelope.attackIn <- 0.001f;
+                    envelope.releaseIn <- .2f + vel * 0.1f;
+                    envelope.triggerIn <- void;
+                    envelope.advance();
+                    float gain = envelope.gainOut;
+                    while (gain > 0.0f && triggerVelocity == 0.0f) {
+                        osc1.frequencyModIn <- gain * 0.03f;
+                        float lpSample = lowpass.getSample(noiseIn, 15000.0f, 0.7f, invSampleRate);
+                        let outSample = (sin(osc1.out * (1.0f + vel * 0.5f)) + lpSample * 0.6f) * gain * 0.5f * vel * outputLevel;
+
+                        float pan = panning * 0.01f;
+                        float leftGain  = 0.5f * (1.0f - pan);
+                        float rightGain = 0.5f * (1.0f + pan);
+                        out <- (outSample * leftGain, outSample * rightGain);
+
+                        osc1.advance();
+                        
+                        gain = envelope.gainOut;
+                        envelope.advance();
+                        advance();
+                    }
+                }
+            }
+        }
+    }
+}

percupuff.cmajorpatch

@@ -20,6 +20,7 @@
     "dsp/Envelope.cmajor",
     "dsp/drums/BassDrum.cmajor",
     "dsp/drums/Snare.cmajor",
+    "dsp/drums/ElectricSnare.cmajor",
     "dsp/drums/Hihat.cmajor",
     "dsp/drums/Clap.cmajor",
     "dsp/drums/Cowbell.cmajor",
@@ -35,4 +36,4 @@
     "height": 533,
     "resizable": false
   }
-}
+}