add juce to gitignore

Source/dsp/WaveTables.h

@@ -2,6 +2,7 @@
 
 #include <cmath>
 #include <algorithm>
+#include <cstdint>
 #include <random>
 
 namespace monostep
@@ -16,9 +17,15 @@ enum class Waveform : int
     pulse = 4,
     noise = 5,
     sub = 6,
-    pluck = 7
+    pluck = 7,
+    super = 8,
+    sah = 9,
+    formant = 10,
+    pwm = 11
 };
 
+static constexpr int numWaveforms = 12;
+
 inline float frac (float x)
 {
     return x - std::floor (x);
@@ -93,6 +100,57 @@ inline float renderWave (Waveform w, float phase, float inc)
             const float f = frac (phase);
             return 2.0f * std::sin (f * 6.283185307179586f * 2.0f) * std::exp (-10.0f * f);
         }
+
+        case Waveform::super:
+        {
+            // A small detuned stack of band-limited saws -> fat, chorus-like lead.
+            float sum = 0.0f;
+            const float detunes[3] = { -0.01f, 0.0f, 0.01f };
+
+            for (const float d : detunes)
+            {
+                const float f = frac (phase + d);
+                sum += (2.0f * f - 1.0f) - polyBlep (f, inc);
+            }
+
+            return sum / 3.0f;
+        }
+
+        case Waveform::sah:
+        {
+            // Sample & hold: a stepped random level per fraction of the cycle.
+            // Deterministic (no shared state) so each oscillator is independent.
+            const int steps = 16;
+            const float f = frac (phase);
+            int s = static_cast<int> (std::floor (f * (float) steps));
+            if (s >= steps) s = steps - 1;
+            if (s < 0)      s = 0;
+
+            std::uint32_t h = static_cast<std::uint32_t> (s);
+            h ^= h << 13;  h ^= h >> 17;  h ^= h << 5;
+            const float r = static_cast<float> (h & 0xffffff) / 16777215.0f;
+
+            return r * 2.0f - 1.0f;
+        }
+
+        case Waveform::formant:
+        {
+            // Two formant-like bands via slow AM sidebands (fixed ratios).
+            const float w = phase * 6.283185307179586f;
+            const float env = 0.5f + 0.3f * std::cos (w * 0.5f) + 0.2f * std::cos (w * 0.25f);
+            return std::sin (w) * env;
+        }
+
+        case Waveform::pwm:
+        {
+            // Fixed 20 % pulse, band-limited at both edges.
+            const float width = 0.2f;
+            const float f = frac (phase);
+            float v = (f < width) ? 1.0f : -1.0f;
+            v += polyBlep (f, inc);
+            v -= polyBlep (frac (f + 1.0f - width), inc);
+            return v;
+        }
     }
 
     return 0.0f;