feat(dsp): add core synthesizer oscillators, wavetable and voice engine

Source/Oscillator.cpp

@@ -0,0 +1,133 @@
+#include "Oscillator.h"
+
+namespace serum
+{
+
+void Oscillator::reset()
+{
+    for (auto& v : voices)
+    {
+        v.phase       = 0.0;
+        v.detuneRatio = 1.0;
+        v.pan         = 0.0f;
+        v.level       = 1.0f;
+    }
+    activeUnison = 1;
+}
+
+void Oscillator::noteOn (double freqHz, const OscParams& p, juce::uint32 seed)
+{
+    jassert (freqHz > 0.0);
+    rng.setSeed (seed);
+
+    const int uni = juce::jlimit (1, kMaxUnison, p.unison);
+    activeUnison  = uni;
+
+    const double basePhase = (double) p.phase * kTwoPi;
+
+    for (int v = 0; v < uni; ++v)
+    {
+        // Even phase spacing prevents cancellation across unison voices.
+        double offset = (uni > 1) ? ((double) v / (double) uni) * kTwoPi : 0.0;
+        double random = rng.nextFloat() * (double) p.randPhase * kTwoPi;
+        voices[(size_t) v].phase = basePhase + offset + random;
+
+        // Detune: linear spread in cents, 0..50 cents at full depth.
+        double detuneCents = 0.0;
+        if (uni > 1)
+            detuneCents = (double) p.detune * 50.0 * ((double) (v - (uni - 1) / 2.0) / (double) ((uni - 1) / 2.0));
+        voices[(size_t) v].detuneRatio = std::pow (2.0, detuneCents / 1200.0);
+
+        // Stereo spread.
+        float panPos = (uni > 1) ? ((float) v / (float) (uni - 1) - 0.5f) * 2.0f * p.spread : 0.0f;
+        voices[(size_t) v].pan = panPos;
+
+        // Gain scaling with a centre emphasis for odd unison counts.
+        float lvl = 1.0f / std::sqrt ((float) uni);
+        if ((uni & 1) && v == uni / 2)
+            lvl *= 1.3f;
+        voices[(size_t) v].level = lvl;
+    }
+}
+
+float Oscillator::warpPhase (float phase, const OscParams& p) const noexcept
+{
+    const float amt = p.warpAmt;
+    switch ((WarpMode) p.warp)
+    {
+        case WarpMode::None:      return phase;
+        case WarpMode::BendPlus:  return phase + amt * 0.5f * std::sin (phase * (float) kTwoPi);
+        case WarpMode::BendMinus: return phase - amt * 0.5f * std::sin (phase * (float) kTwoPi);
+        case WarpMode::Sync:      return std::fmod (phase * (1.0f + amt * 7.0f), 1.0f);
+        case WarpMode::Asym:
+            if (amt < 0.001f) return phase;
+            return std::pow (phase, 1.0f + amt * 3.0f);
+        case WarpMode::Mirror:
+        {
+            const float mirror = 2.0f * std::abs (phase - 0.5f);
+            return phase + (mirror - phase) * amt;
+        }
+        case WarpMode::PWM: return phase;
+        case WarpMode::Fold: return phase;
+        default: return phase;
+    }
+}
+
+float Oscillator::warpSample (float sample, const OscParams& p) const noexcept
+{
+    const float amt = p.warpAmt;
+    switch ((WarpMode) p.warp)
+    {
+        case WarpMode::PWM:
+        {
+            const float threshold = (2.0f * amt - 1.0f) * 0.9f;
+            return std::tanh ((sample - threshold) * 4.0f);
+        }
+        case WarpMode::Fold:
+            return std::sin (sample * (1.0f + amt * 5.0f) * 1.5707963267948966f);
+        default:
+            return sample;
+    }
+}
+
+void Oscillator::processAdd (const Wavetable& wt, const OscParams& p, double freqHz,
+                             float& outL, float& outR) noexcept
+{
+    if (! p.enabled || p.level <= 0.0f || freqHz <= 0.0)
+        return;
+
+    const int uni = juce::jlimit (1, kMaxUnison, p.unison);
+    const float framePos = p.wtPos * 255.0f;
+    const double phaseInc = kTwoPi * freqHz / sr;
+
+    float accL = 0.0f;
+    float accR = 0.0f;
+
+    for (int v = 0; v < uni; ++v)
+    {
+        auto& sv = voices[(size_t) v];
+
+        sv.phase += phaseInc * sv.detuneRatio;
+        sv.phase -= std::floor (sv.phase * (1.0 / kTwoPi)) * kTwoPi;
+        if (sv.phase >= kTwoPi) sv.phase -= kTwoPi;
+        if (sv.phase < 0.0)     sv.phase += kTwoPi;
+
+        float phase01 = (float) (sv.phase * (1.0 / kTwoPi));
+        float sample  = wt.readSafe (framePos, warpPhase (phase01, p));
+        sample        = warpSample (sample, p);
+
+        // Constant-power pan.
+        const float panAngle = (sv.pan + 1.0f) * 0.5f * 1.5707963267948966f;
+        const float panL = std::cos (panAngle);
+        const float panR = std::sin (panAngle);
+
+        const float gain = sv.level * p.level;
+        accL += sample * gain * panL;
+        accR += sample * gain * panR;
+    }
+
+    outL += accL;
+    outR += accR;
+}
+
+} // namespace serum