Implement dsp cmajor code for ride bell (#79)

* Add ride bell parameters and instrument definition

* Add Ride Bell instrument and integrate into synthesizer

* Format the code

* Update Ride Bell parameters and add instrument to the UI

Author: RakinduM

dsp/Params.cmajor

@@ -82,6 +82,10 @@ namespace Percupuff
         float cowbellPanning;
         float cowbellVelocity;
         float cowbellMidi;
+        float rideBellLevel;
+        float rideBellPanning;
+        float rideBellVelocity;
+        float rideBellMidi;
         float sideStickLevel;
         float sideStickPanning;
         float sideStickVelocity;
@@ -165,6 +169,10 @@ namespace Percupuff
         p.cowbellPanning = 0.0f;
         p.cowbellVelocity = 100.0f;
         p.cowbellMidi = 56.0f;
+        p.rideBellLevel = 50.0f;
+        p.rideBellPanning = 0.0f;
+        p.rideBellVelocity = 100.0f;
+        p.rideBellMidi = 53.0f;
         p.sideStickLevel = 50.0f;
         p.sideStickPanning = 0.0f;
         p.sideStickVelocity = 100.0f;
@@ -248,6 +256,10 @@ namespace Percupuff
         input event float cowbellPanning [[ name: "cowbellPanning", min: -100, max: 100, init: 0, step: 5 ]];
         input event float cowbellVelocity [[ name: "cowbellVelocity", min: 0, max: 100, init: 100, step: 1 ]];
         input event float cowbellMidi [[ name: "cowbellMidi", min: 0, max: 127, init: 56, step: 1 ]];
+        input event float rideBellLevel [[ name: "rideBellLevel", min: 0, max: 100, init: 50, step: 1 ]];
+        input event float rideBellPanning [[ name: "rideBellPanning", min: -100, max: 100, init: 0, step: 5 ]];
+        input event float rideBellVelocity [[ name: "rideBellVelocity", min: 0, max: 100, init: 100, step: 1 ]];
+        input event float rideBellMidi [[ name: "rideBellMidi", min: 0, max: 127, init: 53, step: 1 ]];
         input event float sideStickLevel [[ name: "sideStickLevel", min: 0, max: 100, init: 50, step: 1 ]];
         input event float sideStickPanning [[ name: "sideStickPanning", min: -100, max: 100, init: 0, step: 5 ]];
         input event float sideStickVelocity [[ name: "sideStickVelocity", min: 0, max: 100, init: 100, step: 1 ]];
@@ -334,6 +346,10 @@ namespace Percupuff
         event cowbellPanning (float f) { params.cowbellPanning = f; update(); }
         event cowbellVelocity (float f) { params.cowbellVelocity = f; update(); }
         event cowbellMidi (float f) { params.cowbellMidi = f; update(); }
+        event rideBellLevel (float f) { params.rideBellLevel = f; update(); }
+        event rideBellPanning (float f) { params.rideBellPanning = f; update(); }
+        event rideBellVelocity (float f) { params.rideBellVelocity = f; update(); }
+        event rideBellMidi (float f) { params.rideBellMidi = f; update(); }
         event sideStickLevel (float f) { params.sideStickLevel = f; update(); }
         event sideStickPanning (float f) { params.sideStickPanning = f; update(); }
         event sideStickVelocity (float f) { params.sideStickVelocity = f; update(); }

dsp/Percupuff.cmajor

@@ -38,6 +38,7 @@ namespace Percupuff
             claves = Drums::Claves;
             bongos = Drums::Bongos;
             sideStick = Drums::SideStick;
+            rideBell = Drums::RideBell;
             gainLimiter = std::levels::ConstantGain (float<2>, 1.0f);
             mpe = std::midi::MPEConverter;
         }
@@ -55,6 +56,7 @@ namespace Percupuff
             p.paramsOut -> snare.paramsIn;
             p.paramsOut -> electricSnare.paramsIn;
             p.paramsOut -> sideStick.paramsIn;
+            p.paramsOut -> rideBell.paramsIn;
 
             // Send the midi events so the sound processors know when to start playing.
             midiIn -> mpe;
@@ -68,6 +70,7 @@ namespace Percupuff
             mpe -> claves.eventIn;
             mpe -> bongos.eventIn;
             mpe -> sideStick.eventIn;
+            mpe -> rideBell.eventIn;
             mpe -> noteOn;
 
             // Some sounds use noise.
@@ -90,6 +93,7 @@ namespace Percupuff
             claves -> gainLimiter;
             bongos -> gainLimiter;
             sideStick -> gainLimiter;
+            rideBell -> gainLimiter;
 
             // Output the result.
             gainLimiter -> out;

dsp/drums/RideBell.cmajor

@@ -0,0 +1,118 @@
+namespace Percupuff
+{
+    namespace Drums
+    {
+        processor RideBell {
+            input event (std::notes::NoteOn) eventIn;
+            output stream float<2> out;
+            input event Params paramsIn;
+
+            float triggerVelocity = 0.0f;
+            int midiNotePitch = 0;
+            float outputLevel = 0.5f;
+            float panning = 0.0f;
+
+            // Velocity sensitivity is not implemented yet
+            float velocitySensitivity = 1.0f;
+
+            event paramsIn(Params p) {
+                midiNotePitch = int(p.rideBellMidi);
+                outputLevel = p.rideBellLevel * 0.01f;
+                panning = p.rideBellPanning;
+                velocitySensitivity = p.rideBellVelocity;
+            }
+
+            event eventIn(std::notes::NoteOn n) {
+                if (int (n.pitch) == midiNotePitch) {
+                    triggerVelocity = sqrt(n.velocity);
+                }
+            }
+
+            node envelope = Envelope;
+            node osc1 = Oscillator(OscillatorShape::sine);
+            node osc2 = Oscillator(OscillatorShape::sine);
+            node osc3 = Oscillator(OscillatorShape::sine);
+            node osc4 = Oscillator(OscillatorShape::sine);
+
+            const float highPassCutoff = 1400.0f;
+            node highpass = std::filters::butterworth::Processor(
+                std::filters::butterworth::Mode::highPass, highPassCutoff
+            );
+
+            const float lowPassCutoff = 12000.0f;
+            node lowpass = std::filters::butterworth::Processor(
+                std::filters::butterworth::Mode::lowPass, lowPassCutoff
+            );
+
+            void main()
+            {
+                envelope.attackIn <- 0.001f;
+                envelope.releaseIn <- 1.0f;
+
+                loop
+                {
+                    while (triggerVelocity == 0) {
+                        advance();
+                    }
+
+                    let vel = triggerVelocity;
+                    triggerVelocity = 0.0f;
+
+                    envelope.triggerIn <- void;
+                    envelope.releaseIn <- 0.8f + vel * 0.4f;
+                    envelope.advance();
+
+                    // Base frequency and inharmonic ratios
+                    float baseFreq = 1040.0f;
+                    float ratio1 = 1.0f;
+                    float ratio2 = 1.52f;
+                    float ratio3 = 2.03f;
+                    float ratio4 = 2.87f;
+
+                    osc1.frequencyIn <- baseFreq * ratio1;
+                    osc2.frequencyIn <- baseFreq * ratio2;
+                    osc3.frequencyIn <- baseFreq * ratio3;
+                    osc4.frequencyIn <- baseFreq * ratio4;
+
+                    // Slight detuning
+                    osc2.frequencyModIn <- 0.3f;
+                    osc3.frequencyModIn <- -0.2f;
+
+                    float gain = envelope.gainOut;
+
+                    while (gain > 0.001f && triggerVelocity == 0.0f)
+                    {
+                        // Mix oscillators into a temporary variable
+                        let sample = (osc1.out * 0.4f +
+                                      osc2.out * 0.3f +
+                                      osc3.out * 0.2f +
+                                      osc4.out * 0.1f) * gain * vel * outputLevel;
+
+                        // Apply highpass and lowpass filtering
+                        highpass.in <- sample;
+                        lowpass.in <- highpass.out;
+
+                        let filtered = lowpass.out;
+
+                        float pan = panning * 0.01f;
+                        float leftGain  = 0.5f * (1.0f - pan);
+                        float rightGain = 0.5f * (1.0f + pan);
+                        out <- (filtered * leftGain, filtered * rightGain);
+
+                        osc1.advance();
+                        osc2.advance();
+                        osc3.advance();
+                        osc4.advance();
+                        highpass.advance();
+                        lowpass.advance();
+                        envelope.advance();
+                        advance();
+
+                        gain = envelope.gainOut;
+                    }
+                }
+            }
+
+        }
+    }
+}

percupuff.cmajorpatch

@@ -28,6 +28,7 @@
     "dsp/drums/Claves.cmajor",
     "dsp/drums/Bongos.cmajor",
     "dsp/drums/SideStick.cmajor",
+    "dsp/drums/RideBell.cmajor",
     "dsp/Percupuff.cmajor"
   ],
   "view": {

view/src/params.ts

@@ -16,6 +16,8 @@ export const instruments = {
   crash2: { name: "Crash Cymbal 2", group: "Crash Cymbals", midi: 57 },
   crash3: { name: "Crash Cymbal 3", group: "Crash Cymbals", midi: 52 },
 
+  rideBell: { name: "Ride Bell", group: "🔔", midi: 53 },
+
   bongo1: { name: "High Bongo", group: "Bongos", midi: 60 },
   bongo2: { name: "Low Bongo", group: "Bongos", midi: 61 },
 
@@ -47,6 +49,7 @@ export const groupColors: Record<InstrumentGroup, HSL> = {
   Snares: HSL(60, 80, 40),
   Hihats: HSL(120, 58, 41),
   ["Crash Cymbals"]: HSL(60, 80, 40),
+  ["🔔"]: HSL(10, 50, 45),
   Bongos: HSL(60, 80, 40),
   ["Wood Sounds"]: HSL(120, 58, 41),
   Toms: HSL(10, 50, 45),