From 3331b4cc161adeeab3438d0b4afaa559c61a014d Mon Sep 17 00:00:00 2001 From: Armin Date: Thu, 13 Aug 2026 00:38:10 +0200 Subject: [PATCH] add arpeggiator, rename presets, move spectrum analyzer into waveform --- AGENTS.md | 104 +++++---- CMakeLists.txt | 12 ++ Source/DSP/Arpeggiator.h | 225 ++++++++++++++++++++ Source/PluginEditor.cpp | 275 +++++++++++++++--------- Source/PluginEditor.h | 21 +- Source/PluginProcessor.cpp | 102 ++++++++- Source/PluginProcessor.h | 20 +- Source/PresetManager.h | 424 ++++++++++++++++++------------------- Tools/LevelNormalizer.cpp | 330 +++++++++++++++++++++++++++++ 9 files changed, 1122 insertions(+), 391 deletions(-) create mode 100644 Source/DSP/Arpeggiator.h create mode 100644 Tools/LevelNormalizer.cpp diff --git a/AGENTS.md b/AGENTS.md index 5680c0f..ec7252d 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -86,7 +86,7 @@ Osc1 + Osc2 → Amplitude Envelope × Velocity → Filter (cutoff modulated by F - `processBlock()`: clears buffer, calls `updateVoiceParameters()`, then `synth.renderNextBlock()` - State save/restore via XML binary copy -### Parameters (27 total) +### Parameters (32 total) | ID | Name | Range | Default | |---------------------|------------------|--------------------|---------| @@ -117,6 +117,11 @@ Osc1 + Osc2 → Amplitude Envelope × Velocity → Filter (cutoff modulated by F | pan | Pan | -1..1 | 0 | | drive | Drive | 1..5 (log) | 1.5 | | masterLevel | Master Level | 0..1 | 0.8 | +| arpEnabled | Arp On | Choice(2) Off/On | 0 (Off) | +| arpPattern | Arp Pattern | Choice(7) | 0 (Up) | +| arpOctaves | Arp Octaves | Choice(3) 1/2/3 | 1 (2) | +| arpDirection | Arp Direction | Choice(2) Up/Down | 0 (Up) | +| arpRate | Arp Rate | Choice(6) 1/16..2 | 1 (1/8) | ## UI Architecture @@ -137,22 +142,31 @@ ChromaFlockEditor (juce::AudioProcessorEditor) ### Layout Dimensions (base coordinates, 1× scale) - **baseWidth**: 1660 -- **baseHeight**: 480 (needs to increase to ~620 for visualizers) -- **Section Y origin**: 56px (below header line at y=48) -- **Knob size**: 112×112 -- **Knob spacing**: 10px -- **Label height**: 18px -- **Combo box height**: 48px +- **baseHeight**: 1028 +- **Header**: y 0..80 (logo + preset buttons + transpose + scale) +- **Knob size**: 112×112 (main rows), 80×80 (FX/LFO rows) +- **Visualizer row**: y=746, h=128 (VU meter, waveform w/ spectrum overlay, arpeggiator) +- **Piano roll**: y=884, h=136 ### Section Layout (from paint/drawSection calls) -| Section | X | Y | W | H | -|------------|------|-----|------|------| -| OSC 1 | 10 | 52 | 498 | 200 | -| OSC 2 | 520 | 52 | 620 | 200 | -| FILTER | 1152 | 52 | 498 | 200 | -| AMP ENV | 10 | 262 | 498 | 150 | -| FILTER ENV | 520 | 262 | 498 | 150 | -| MASTER | 1030 | 262 | 376 | 150 | +| Section | X | Y | W | H | +|--------------|------|-----|------|------| +| OSC 1 | 10 | 80 | 498 | 200 | +| OSC 2 | 518 | 80 | 624 | 200 | +| FILTER | 1152 | 80 | 498 | 200 | +| AMP ENV | 10 | 290 | 563 | 160 | +| FILTER ENV | 583 | 290 | 502 | 160 | +| MASTER | 1095 | 290| 555 | 160 | +| DISTORTION | 10 | 460 | 510 | 115 | +| COMPRESSION | 528 | 460 | 468 | 115 | +| PANNING | 1004 | 460 | 268 | 115 | +| LIMITER | 1280 | 460 | 370 | 115 | +| LFO 1 | 10 | 586 | 540 | 150 | +| LFO 2 | 560 | 586 | 530 | 150 | +| DELAY | 1015 | 586 | 375 | 150 | +| REVERB | 1395 | 586 | 255 | 150 | +| ARPEGGIATOR | 860 | 746 | 790 | 128 | +| PIANO ROLL | 10 | 884 | 1640 | 136 | ### Look-and-Feel (KnobLookAndFeel) - Inherits `juce::LookAndFeel_V4` @@ -166,8 +180,9 @@ ChromaFlockEditor (juce::AudioProcessorEditor) - Knob labels: `0xff888888`, 10pt font - Text boxes: `0xffcccccc` text on `0xff1a1a1a` background -### ComboBox LAF (not yet implemented — currently uses default V4 look) -- Needs custom 3D LAF similar to knobs (gradient, shadow, highlight) +### ComboBox LAF (implemented — `ComboBoxLookAndFeel`) +- Custom 3D LAF (gradient spotlight, drop shadow, gold arrow, highlighted popup items) +- `drawPopupMenuItem` highlights the selected entry persistently and inverts text color on hover ### Header - Title: "CHROMAFLOCK" at (20, 8), 22pt bold gold @@ -178,47 +193,28 @@ ChromaFlockEditor (juce::AudioProcessorEditor) - Scale label at (1520, 10), 42×20 - Scale combo at (1566, 8), 80×24 -## Planned / In-Progress Work +## Implemented Features -### Filter Crash Fix (HIGH PRIORITY) -**Problem**: Single `Filter filter` in `SubtractiveVoice` is called for both L and R in sequence (lines 87-88 of Voice.h). The filter's internal state (`stage[4]`) is shared/corrupted between channels, causing instability when filter env amount > 0. +### Filter Crash Fix +`SubtractiveVoice` now has separate `filter` (L) and `filterR` (R) instances; `startNote()` prepares both. Resolves the state-sharing crash when filter env amount > 0. -**Fix**: Add `Filter filterR` member. In `renderNextBlock()`: -- Process left channel through `filter` -- Process right channel through `filterR` -- In `startNote()`, call `filter.prepare(sr)` AND `filterR.prepare(sr)` +### Arpeggiator +- New class `DSP/Arpeggiator.h` — tempo-synced, pure note-logic (no audio). Tracks held notes (press order for the As Played pattern), builds a pitch pool from held notes × octave range (1–3, clamped to MIDI range), and sequences it per pattern. +- Patterns: Up, Down, UpDown, DownUp, Random, As Played, Chord. +- `arpDirection` (Up/Down) controls whether octave copies extend above or below the root; sequential patterns always order by ascending pitch. +- `arpRate` step divisions (beats): 1/16, 1/8, 1/4, 1/2, 1, 2 — tick period = `rateBeats * 60 / bpm`. +- Routing (`PluginProcessor.cpp::processBlock`): when `arpEnabled`, MIDI note events feed the arp instead of the synth; the arp drives `synth.noteOn/noteOff` (with transpose) on each tick via `arpSampleCount` accumulation. Piano-roll `noteOn/noteOff` route through the same logic. When disabled, `arp.reset()` stops any sounding arp note and notes play normally. +- UI: bottom-right section at (860, 746) titled ARPEGGIATOR with 5 combos (ON, PATTERN, OCTAVES, DIR, RATE). -### Scope Buffer for Visualizers (HIGH PRIORITY) -**Need to add to `ChromaFlockProcessor`**: -- `std::array scopeBuffer` — ring buffer for waveform data -- `std::atomic scopeWritePos` — write position index -- Write to buffer in `processBlock()` after `synth.renderNextBlock()`, interleaving L+R samples -- Add getter method: `const float* getScopeData() const` -- Add `juce::juce_dsp` to CMakeLists.txt for FFT +### Visualizers +- `WaveformDisplay` (bottom-left, 60×746, 790×128) draws the scope ring buffer waveform AND a semi-transparent `juce::dsp::FFT` spectrum overlay behind it (30 fps). Requires `juce::juce_dsp` linked and `#include `. +- Standalone `SpectrumAnalyzer` component was removed. -### Visualizer Components (HIGH PRIORITY) -Two new classes to add to `PluginEditor.h`: - -**WaveformDisplay** (juce::Component) -- Reads from processor scope buffer -- Draws waveform as line graph on dark background -- Timer callback at 30fps -- Positioned at bottom-left of UI (~190px tall, ~830px wide) - -**SpectrumDisplay** (juce::Component) -- Uses `juce::dsp::FFT` to compute spectrum from scope buffer -- Draws vertical bars with HSV color gradient (cool→warm based on frequency) -- Timer callback at 30fps -- Positioned at bottom-right of UI (~190px tall, ~830px wide) - -### Height Expansion -- `baseHeight` must increase from 480 to ~620 -- Bottom sections (AMP ENV, FILTER ENV, MASTER) at y=262 currently end at y=412 -- Visualizers fill the remaining space (y=412 to y=612) -- Editor window resized accordingly - -### ComboBox 3D LAF (MEDIUM PRIORITY) -Custom look-and-feel for combo boxes matching the 3D knob aesthetic. +### Preset Level Normalization (`Tools/LevelNormalizer.cpp`) +- Standalone JUCE console tool that renders every preset offline (C4, 8s, 44.1 kHz) and derives a new `masterLevel` for consistent loudness: peak normalized to 0.80, RMS-normalized to 0.15, final value = `min(gainPeak, gainRms) * current`, clamped to 0..1. +- Build target: `cmake --build build --target level_normalizer`; run `./build/level_normalizer --apply` to rewrite the `masterLevel` entries in `Source/PresetManager.h` (reports a count mismatch and aborts if preset order/count ever drifts). +- Applied 2026: all 136 presets re-balanced; `masterLevel` now ranges 0.325..1.0. Sustained/washy presets (heavy reverb/delay) get the largest cuts; quiet transient presets clamp at 1.0. +- Caveat: noise-based presets render with slight run-to-run variance (`juce::Random` reseeds per process), so re-running can shift borderline values by a few percent. ## Common Pitfalls & Gotchas diff --git a/CMakeLists.txt b/CMakeLists.txt index 7b1e2a5..d121253 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -98,3 +98,15 @@ target_link_libraries(ChromaFlock PRIVATE juce::juce_gui_basics juce::juce_gui_extra ) + +# Offline preset-loudness calibration tool (not built by default). +# Usage: ./level_normalizer (dry run) +# ./level_normalizer --apply (write new masterLevels into PresetManager.h) +add_executable(level_normalizer EXCLUDE_FROM_ALL Tools/LevelNormalizer.cpp) +target_compile_definitions(level_normalizer PUBLIC + JUCE_APPLICATION_NAME=LevelNormalizer + JUCE_APPLICATION_VERSION=1.0.0 +) +target_link_libraries(level_normalizer PRIVATE + juce::juce_audio_processors +) diff --git a/Source/DSP/Arpeggiator.h b/Source/DSP/Arpeggiator.h new file mode 100644 index 0000000..8984169 --- /dev/null +++ b/Source/DSP/Arpeggiator.h @@ -0,0 +1,225 @@ +#pragma once +#include +#include +#include + +// Tempo-synced arpeggiator. Tracks held notes and, on each clock step, +// produces the notes to play for the selected pattern / octave range / +// direction. Pure note logic — timing is driven from outside (the audio +// thread) via step(). +class Arpeggiator { +public: + enum Pattern { + Up = 0, + Down, + UpDown, + DownUp, + Random, + AsPlayed, + Chord, + numPatterns + }; + + enum Direction { + DirectionUp = 0, + DirectionDown + }; + + struct NotePitch { + int note; + float velocity; + }; + + void setParameters(bool enabled, int pattern, int octaves, int direction, + double rateBeats, double bpm) { + this->enabled = enabled; + this->pattern = pattern < 0 ? Up : (pattern >= numPatterns ? Chord : pattern); + this->octaves = octaves < 1 ? 1 : (octaves > 3 ? 3 : octaves); + this->direction = (direction == DirectionDown) ? DirectionDown : DirectionUp; + this->rateBeats = rateBeats; + this->bpm = bpm > 0.0 ? bpm : 120.0; + } + + bool isEnabled() const { return enabled; } + + double getTickSeconds() const { + return rateBeats * 60.0 / bpm; + } + + void noteOn(int note, float velocity) { + if (note < 0 || note > 127) return; + if (std::find(heldNotes.begin(), heldNotes.end(), note) != heldNotes.end()) + return; + bool wasIdle = heldNotes.empty(); + heldNotes.push_back(note); + velocities[note] = velocity; + // A fresh key press should sound immediately instead of waiting for + // the next host-synced tick. + if (wasIdle) + needsImmediateStep = true; + } + + void noteOff(int note) { + auto it = std::find(heldNotes.begin(), heldNotes.end(), note); + if (it != heldNotes.end()) + heldNotes.erase(it); + } + + bool hasHeldNotes() const { return !heldNotes.empty(); } + + // Returns true if the next step should fire right now (a fresh key press + // requested an immediate trigger) and clears the request. + bool shouldTriggerNow() { + bool v = needsImmediateStep; + needsImmediateStep = false; + return v; + } + + // Clears held notes and step state. Notes that were sounding when reset + // was called are returned so the caller can issue note-offs. + void reset(std::vector& notesToStop) { + notesToStop.swap(currentNotes); + heldNotes.clear(); + stepIndex = 0; + needsImmediateStep = false; + } + + // Advances one step. Notes that should stop go into `notesToStop` + // (usually the note(s) from the previous step); notes that should start + // go into `notesToPlay`. + void step(std::vector& notesToStop, std::vector& notesToPlay) { + notesToStop.clear(); + notesToPlay.clear(); + + if (!enabled) return; + + if (heldNotes.empty()) { + notesToStop = currentNotes; + currentNotes.clear(); + stepIndex = 0; + return; + } + + std::vector pool; + buildPool(pool); + + if (pool.empty()) { + notesToStop = currentNotes; + currentNotes.clear(); + return; + } + + if (pattern == Chord) { + notesToStop = currentNotes; + notesToPlay = pool; + currentNotes.clear(); + for (const auto& np : pool) + currentNotes.push_back(np.note); + return; + } + + auto order = buildOrder(pool); + if (order.empty()) { + notesToStop = currentNotes; + currentNotes.clear(); + return; + } + + int idx = stepIndex % static_cast(order.size()); + ++stepIndex; + + const NotePitch& np = order[idx]; + + notesToStop = currentNotes; + currentNotes.clear(); + currentNotes.push_back(np.note); + notesToPlay.push_back(np); + } + +private: + void buildPool(std::vector& pool) const { + bool used[128] = {}; + auto addPitch = [&](int pitch, float velocity) { + pitch = pitch < 0 ? 0 : (pitch > 127 ? 127 : pitch); + if (used[pitch]) return; + used[pitch] = true; + pool.push_back({pitch, velocity}); + }; + + if (pattern == AsPlayed) { + for (int n : heldNotes) { + for (int k = 0; k < octaves; ++k) { + int off = (direction == DirectionUp ? 12 * k : -12 * k); + addPitch(n + off, velocities[n]); + } + } + } else { + std::vector sorted(heldNotes.begin(), heldNotes.end()); + std::sort(sorted.begin(), sorted.end()); + for (int n : sorted) { + for (int k = 0; k < octaves; ++k) { + int off = (direction == DirectionUp ? 12 * k : -12 * k); + addPitch(n + off, velocities[n]); + } + } + } + } + + std::vector buildOrder(const std::vector& pool) { + // Sequential patterns play by ascending pitch regardless of the + // octave direction; As Played keeps the key-press order. + std::vector seq(pool); + std::sort(seq.begin(), seq.end(), + [](const NotePitch& a, const NotePitch& b) { return a.note < b.note; }); + int n = static_cast(seq.size()); + + std::vector order; + auto push = [&](int i) { order.push_back(seq[i]); }; + + switch (pattern) { + case Down: + for (int i = n - 1; i >= 0; --i) push(i); + break; + case UpDown: + for (int i = 0; i < n; ++i) push(i); + for (int i = n - 2; i >= 1; --i) push(i); + break; + case DownUp: + for (int i = n - 1; i >= 0; --i) push(i); + for (int i = 1; i < n - 1; ++i) push(i); + break; + case Random: + order = seq; + for (int i = n - 1; i > 0; --i) { + int j = static_cast(randomState % static_cast(i + 1)); + std::swap(order[i], order[j]); + randomState = randomState * 1664525u + 1013904223u; + } + break; + case AsPlayed: + order = pool; + break; + case Chord: + case Up: + default: + for (int i = 0; i < n; ++i) push(i); + break; + } + return order; + } + + bool enabled = false; + int pattern = Up; + int octaves = 1; + int direction = DirectionUp; + double rateBeats = 0.5; + double bpm = 120.0; + + std::vector heldNotes; + float velocities[128] = {}; + std::vector currentNotes; + int stepIndex = 0; + bool needsImmediateStep = false; + + uint32_t randomState = 0x12345678u; +}; diff --git a/Source/PluginEditor.cpp b/Source/PluginEditor.cpp index 1f76710..092d1c0 100644 --- a/Source/PluginEditor.cpp +++ b/Source/PluginEditor.cpp @@ -197,7 +197,7 @@ void VuMeter::paint(juce::Graphics& g) { g.drawText("VU", bounds.withBottom(bounds.getY() + 22.0f).translated(0, 6), juce::Justification::centred); } -// --- Waveform Display --- +// --- Waveform Display (with semi-transparent spectrum overlay) --- void WaveformDisplay::paint(juce::Graphics& g) { auto bounds = getLocalBounds().toFloat().reduced(0.5f); @@ -209,6 +209,116 @@ void WaveformDisplay::paint(juce::Graphics& g) { g.setColour(juce::Colour(0xff333333)); g.drawRoundedRectangle(bounds, 9.0f, 1.0f); + // ---- Spectrum overlay (half-transparent, drawn behind the waveform) ---- + if (fft != nullptr) { + std::array fftData{}; + int writePos = processor.fftWritePos.load(std::memory_order_acquire); + int fftSize = ChromaFlockProcessor::fftSize; + + for (int i = 0; i < fftSize; ++i) { + int idx = (writePos + i) % fftSize; + fftData[i] = processor.fftInput[idx]; + } + + for (int i = 0; i < fftSize; ++i) { + float window = 0.5f - 0.5f * std::cos(2.0f * 3.14159265f * static_cast(i) / static_cast(fftSize)); + fftData[i] *= window; + } + + fft->performFrequencyOnlyForwardTransform(fftData.data()); + + int numPoints = 128; + float w = bounds.getWidth(); + float h = bounds.getHeight() - 22.0f; + float bottom = bounds.getBottom() - 2.0f; + int maxBin = fftSize / 4; + float sampleRate = static_cast(processor.getSampleRate()); + float binHz = sampleRate / static_cast(fftSize); + const float dbFloor = -48.0f; + + // Log-frequency mapping so the low end (sub bass) spreads across the + // display instead of bunching up in the leftmost ~10%. + const float fLow = 20.0f; + const float fHigh = static_cast(maxBin) * binHz; + const float logRange = std::log(fHigh / fLow); + + if (specSmooth.size() != static_cast(numPoints + 1)) + specSmooth.assign(numPoints + 1, 0.0f); + + std::vector mags(numPoints + 1); + for (int i = 0; i <= numPoints; ++i) { + float t = static_cast(i) / static_cast(numPoints); + float tN = juce::jmin(t + 1.0f / static_cast(numPoints), 1.0f); + float fL = fLow * std::exp(logRange * t); + float fN = fLow * std::exp(logRange * tN); + int binStart = juce::jmax(1, static_cast(fL / binHz)); + int binEnd = static_cast(fN / binHz) + 1; + if (binEnd <= binStart) binEnd = binStart + 1; + if (binEnd > maxBin) binEnd = maxBin; + + float mag = 0.0f; + int count = 0; + for (int b = binStart; b < binEnd; ++b) { + mag += fftData[b]; + ++count; + } + mag = count > 0 ? mag / static_cast(count) : 0.0f; + + // dB scale: 0 dB reference ≈ full-scale sine peak, floor at dbFloor. + float lin = mag / static_cast(fftSize) * 4.0f; + float db = 20.0f * std::log10(lin + 1.0e-6f); + mags[i] = juce::jlimit(0.0f, 1.0f, (db - dbFloor) / -dbFloor); + } + + // Spatial smoothing between adjacent points (rolling-hill look). + std::vector blurred = mags; + for (int pass = 0; pass < 2; ++pass) { + for (int i = 0; i <= numPoints; ++i) { + float a = mags[static_cast(juce::jmax(0, i - 1))]; + float c = mags[static_cast(juce::jmin(numPoints, i + 1))]; + blurred[static_cast(i)] = (a + 2.0f * mags[static_cast(i)] + c) * 0.25f; + } + mags = blurred; + } + + // Time smoothing (EMA) so the curve glides instead of jumping. + // Asymmetric: fast attack, slower fall — a released note's spectrum + // decays away instead of being held up. + const float emaUp = 0.7f; + const float emaDown = 0.6f; + for (int i = 0; i <= numPoints; ++i) { + float& s = specSmooth[static_cast(i)]; + float m = mags[static_cast(i)]; + float coeff = m > s ? emaUp : emaDown; + s = coeff * s + (1.0f - coeff) * m; + } + + juce::Path specPath; + specPath.startNewSubPath(bounds.getX(), bottom); + for (int i = 0; i <= numPoints; ++i) { + float x = bounds.getX() + (static_cast(i) / static_cast(numPoints)) * w; + float y = bottom - specSmooth[static_cast(i)] * h; + specPath.lineTo(x, y); + } + specPath.lineTo(bounds.getRight(), bottom); + specPath.closeSubPath(); + + { + juce::Graphics::ScopedSaveState saved(g); + juce::Path clipPath; + clipPath.addRoundedRectangle(bounds, 9.0f); + g.reduceClipRegion(clipPath); + + juce::ColourGradient specGrad(juce::Colour(0xff7b94b5).withAlpha(0.5f), 0.0f, bottom, + juce::Colour(0xff2a3a4a).withAlpha(0.4f), 0.0f, bottom - h, false); + g.setGradientFill(specGrad); + g.fillPath(specPath); + + g.setColour(juce::Colour(0xff9db8d8).withAlpha(0.55f)); + g.strokePath(specPath, juce::PathStrokeType(1.2f)); + } + } + g.setColour(juce::Colour(0xff333333)); g.drawLine(bounds.getX(), bounds.getCentreY(), bounds.getRight(), bounds.getCentreY(), 1.0f); @@ -245,12 +355,12 @@ void WaveformDisplay::paint(juce::Graphics& g) { clipPath.addRoundedRectangle(bounds, 9.0f); g.reduceClipRegion(clipPath); - juce::ColourGradient waveGrad(juce::Colour(0xffc59c07).withAlpha(0.5f), 0.0f, bounds.getY(), - juce::Colour(0xff3d2e02).withAlpha(0.4f), 0.0f, bounds.getBottom(), false); + juce::ColourGradient waveGrad(juce::Colour(0xff8fa35a).withAlpha(0.5f), 0.0f, bounds.getY(), + juce::Colour(0xff2e3a18).withAlpha(0.4f), 0.0f, bounds.getBottom(), false); g.setGradientFill(waveGrad); g.fillPath(filledPath); - g.setColour(juce::Colour(0xffc59c07).withAlpha(0.9f)); + g.setColour(juce::Colour(0xff8fa35a).withAlpha(0.9f)); g.strokePath(wavePath, juce::PathStrokeType(1.5f)); } @@ -259,102 +369,6 @@ void WaveformDisplay::paint(juce::Graphics& g) { g.drawText("WAVE", bounds.withBottom(bounds.getY() + 22.0f).translated(0, 6), juce::Justification::centred); } -// --- Spectrum Analyzer --- -void SpectrumAnalyzer::paint(juce::Graphics& g) { - auto bounds = getLocalBounds().toFloat().reduced(0.7f); - - juce::ColourGradient bgGrad(juce::Colour(0xBB222222), bounds.getCentreX(), bounds.getY(), - juce::Colour(0xBB111111), bounds.getCentreX(), bounds.getBottom(), false); - g.setGradientFill(bgGrad); - g.fillRoundedRectangle(bounds, 9.0f); - - g.setColour(juce::Colour(0xff333333)); - g.drawRoundedRectangle(bounds, 9.0f, 1.0f); - - std::array fftData{}; - int writePos = processor.fftWritePos.load(std::memory_order_acquire); - int fftSize = ChromaFlockProcessor::fftSize; - - for (int i = 0; i < fftSize; ++i) { - int idx = (writePos + i) % fftSize; - fftData[i] = processor.fftInput[idx]; - } - - for (int i = 0; i < fftSize; ++i) { - float window = 0.5f - 0.5f * std::cos(2.0f * 3.14159265f * static_cast(i) / static_cast(fftSize)); - fftData[i] *= window; - } - - fft->performFrequencyOnlyForwardTransform(fftData.data()); - - int numPoints = 128; - float w = bounds.getWidth(); - float h = bounds.getHeight() - 22.0f; - float bottom = bounds.getBottom() - 2.0f; - int maxBin = fftSize / 4; - float sampleRate = static_cast(processor.getSampleRate()); - float binHz = sampleRate / static_cast(fftSize); - float lowCut = 80.0f; - float lowPass = 250.0f; - - juce::Graphics::ScopedSaveState savedClip(g); - juce::Path clipPath; - clipPath.addRoundedRectangle(bounds, 9.0f); - g.reduceClipRegion(clipPath); - - std::vector mags(numPoints + 1); - for (int i = 0; i <= numPoints; ++i) { - float t = static_cast(i) / static_cast(numPoints); - int binStart = static_cast(std::pow(t, 2.0f) * static_cast(maxBin)); - int binEnd = static_cast(std::pow(t + 1.0f / static_cast(numPoints), 2.0f) * static_cast(maxBin)); - if (binEnd <= binStart) binEnd = binStart + 1; - if (binEnd > maxBin) binEnd = maxBin; - - float mag = 0.0f; - int count = 0; - for (int b = binStart; b < binEnd; ++b) { - mag += fftData[b]; - ++count; - } - mag = count > 0 ? mag / static_cast(count) : 0.0f; - mag = mag / static_cast(fftSize); - mag = std::sqrt(mag) * 6.0f; - - float centerHz = static_cast((binStart + binEnd) / 2) * binHz; - float rolloff = juce::jlimit(0.0f, 1.0f, (centerHz - lowCut) / (lowPass - lowCut)); - mag *= rolloff; - mags[i] = juce::jlimit(0.0f, 1.0f, mag); - } - - juce::Path wavePath; - wavePath.startNewSubPath(bounds.getX(), bottom); - juce::Path strokePath; - strokePath.startNewSubPath(bounds.getX(), bottom - mags[0] * h); - - for (int i = 0; i <= numPoints; ++i) { - float t = static_cast(i) / static_cast(numPoints); - float x = bounds.getX() + t * w; - float y = bottom - mags[i] * h; - wavePath.lineTo(x, y); - if (i > 0) strokePath.lineTo(x, y); - } - - wavePath.lineTo(bounds.getRight(), bottom); - wavePath.closeSubPath(); - - juce::ColourGradient fillGrad(juce::Colour(0xffc59c07).withAlpha(0.35f), 0.0f, bottom, - juce::Colour(0xffc59c07).withAlpha(0.02f), 0.0f, bottom - h, false); - g.setGradientFill(fillGrad); - g.fillPath(wavePath); - - g.setColour(juce::Colour(0xffc59c07).withAlpha(0.9f)); - g.strokePath(strokePath, juce::PathStrokeType(1.5f)); - - g.setColour(juce::Colour(0xffccaa44)); - g.setFont(juce::Font(juce::FontOptions(13.0f).withStyle("Bold"))); - g.drawText("SPECTRUM", bounds.withBottom(bounds.getY() + 22.0f).translated(0, 6), juce::Justification::centred); -} - // --- Patch LCD (amber dot-matrix) --- namespace { struct Glyph { char c; unsigned char rows[7]; }; @@ -476,7 +490,7 @@ void MidiLed::paint(juce::Graphics& g) { } MainContentComponent::MainContentComponent(ChromaFlockProcessor& p) - : processorRef(p), vuMeter(p), waveformDisplay(p), spectrumAnalyzer(p), pianoRoll(p), midiLed(p) { + : processorRef(p), vuMeter(p), waveformDisplay(p), pianoRoll(p), midiLed(p) { auto setupParam = [&](juce::Slider& knob, std::unique_ptr& attach, const juce::String& paramId, const juce::String& name) { @@ -667,9 +681,29 @@ MainContentComponent::MainContentComponent(ChromaFlockProcessor& p) addAndMakeVisible(vuMeter); addAndMakeVisible(waveformDisplay); - addAndMakeVisible(spectrumAnalyzer); addAndMakeVisible(pianoRoll); + // Arpeggiator section + auto setupArpLabel = [&](juce::Label& label, const juce::String& text) { + label.setText(text, juce::dontSendNotification); + label.setFont(juce::Font(juce::FontOptions(11.0f).withStyle("Bold"))); + label.setColour(juce::Label::textColourId, juce::Colour(0xff888888)); + label.setJustificationType(juce::Justification::centred); + addAndMakeVisible(label); + }; + setupArpLabel(arpEnabledLabel, "ON"); + setupArpLabel(arpPatternLabel, "PATTERN"); + setupArpLabel(arpOctavesLabel, "OCTAVES"); + setupArpLabel(arpDirectionLabel, "DIR"); + setupArpLabel(arpRateLabel, "RATE"); + + setupCB(arpEnabledBox, arpEnabledAttach, "arpEnabled", {"Off", "On"}); + setupCB(arpPatternBox, arpPatternAttach, "arpPattern", + {"Up", "Down", "UpDown", "DownUp", "Random", "As Played", "Chord"}); + setupCB(arpOctavesBox, arpOctavesAttach, "arpOctaves", {"1", "2", "3"}); + setupCB(arpDirectionBox, arpDirectionAttach, "arpDirection", {"Up", "Down"}); + setupCB(arpRateBox, arpRateAttach, "arpRate", {"1/16", "1/8", "1/4", "1/2", "1", "2"}); + setupCombo(uiScaleBox); uiScaleBox.addItem("100%", 1); uiScaleBox.addItem("125%", 2); @@ -1050,6 +1084,9 @@ void MainContentComponent::paint(juce::Graphics& g) { // FX2 sub-sections drawSubSection(1015, 586, 375, 150, "DELAY", 4); drawSubSection(1395, 586, 255, 150, "REVERB", 4); + + // Arpeggiator section (replaces the removed spectrum analyzer) + drawSubSection(860, 746, 790, 128, "ARPEGGIATOR", 6); } void MainContentComponent::resized() { @@ -1242,7 +1279,39 @@ void MainContentComponent::resized() { int vizH = 128; vuMeter.setBounds(10, vizY, 40, vizH); waveformDisplay.setBounds(60, vizY, 790, vizH); - spectrumAnalyzer.setBounds(860, vizY, 790, vizH); + + // Arpeggiator controls (right of the waveform display) + { + int arpX = 860, arpY = vizY, arpW = 790; + int comboH = 28; + int labelH = 16; + int labelY = arpY + 26; + int comboY = labelY + labelH + 8; + + int widths[] = {90, 170, 90, 90, 110}; + int gap = 22; + int totalW = widths[0] + widths[1] + widths[2] + widths[3] + widths[4] + gap * 4; + int x = arpX + (arpW - totalW) / 2; + + arpEnabledLabel.setBounds(x, labelY, widths[0], labelH); + arpEnabledBox.setBounds(x, comboY, widths[0], comboH); + x += widths[0] + gap; + + arpPatternLabel.setBounds(x, labelY, widths[1], labelH); + arpPatternBox.setBounds(x, comboY, widths[1], comboH); + x += widths[1] + gap; + + arpOctavesLabel.setBounds(x, labelY, widths[2], labelH); + arpOctavesBox.setBounds(x, comboY, widths[2], comboH); + x += widths[2] + gap; + + arpDirectionLabel.setBounds(x, labelY, widths[3], labelH); + arpDirectionBox.setBounds(x, comboY, widths[3], comboH); + x += widths[3] + gap; + + arpRateLabel.setBounds(x, labelY, widths[4], labelH); + arpRateBox.setBounds(x, comboY, widths[4], comboH); + } // Piano roll pianoRoll.setBounds(10, 884, 1640, 136); diff --git a/Source/PluginEditor.h b/Source/PluginEditor.h index ef14ede..1500468 100644 --- a/Source/PluginEditor.h +++ b/Source/PluginEditor.h @@ -46,16 +46,7 @@ private: class WaveformDisplay : public juce::Component, public juce::Timer { public: - explicit WaveformDisplay(ChromaFlockProcessor& p) : processor(p) { startTimerHz(30); } - void paint(juce::Graphics& g) override; - void timerCallback() override { repaint(); } -private: - ChromaFlockProcessor& processor; -}; - -class SpectrumAnalyzer : public juce::Component, public juce::Timer { -public: - explicit SpectrumAnalyzer(ChromaFlockProcessor& p) : processor(p) { + explicit WaveformDisplay(ChromaFlockProcessor& p) : processor(p) { fft = std::make_unique(ChromaFlockProcessor::fftOrder); startTimerHz(30); } @@ -64,6 +55,7 @@ public: private: ChromaFlockProcessor& processor; std::unique_ptr fft; + std::vector specSmooth; }; class PatchLCD : public juce::Component { @@ -143,7 +135,6 @@ private: VuMeter vuMeter; WaveformDisplay waveformDisplay; - SpectrumAnalyzer spectrumAnalyzer; PianoRollComponent pianoRoll; juce::Label osc1Label, osc2Label, filterLabel, envLabel, fEnvLabel, globalLabel; @@ -185,6 +176,10 @@ private: juce::ComboBox delaySyncBox; KnobSlider reverbSizeKnob, reverbDampKnob, reverbMixKnob; + // Arpeggiator controls + juce::Label arpEnabledLabel, arpPatternLabel, arpOctavesLabel, arpDirectionLabel, arpRateLabel; + juce::ComboBox arpEnabledBox, arpPatternBox, arpOctavesBox, arpDirectionBox, arpRateBox; + // Preset menu juce::TextButton presetButton{"PRESET"}; PatchLCD patchLCD; @@ -227,6 +222,10 @@ private: std::unique_ptr delayPingPongAttach; std::unique_ptr reverbSizeAttach, reverbDampAttach, reverbMixAttach; + // Arpeggiator attachments + std::unique_ptr arpEnabledAttach, arpPatternAttach, arpOctavesAttach; + std::unique_ptr arpDirectionAttach, arpRateAttach; + void setupLabel(juce::Label& label, const juce::String& text); void setupKnob(juce::Slider& knob, const juce::String& name); void setupCombo(juce::ComboBox& combo); diff --git a/Source/PluginProcessor.cpp b/Source/PluginProcessor.cpp index 350e11f..0c639d8 100644 --- a/Source/PluginProcessor.cpp +++ b/Source/PluginProcessor.cpp @@ -274,6 +274,23 @@ juce::AudioProcessorValueTreeState::ParameterLayout ChromaFlockProcessor::create layout.add(std::make_unique( juce::ParameterID{"reverbMix", 1}, "Reverb Mix", zeroOne, 0.2f)); + // ARPEGGIATOR + layout.add(std::make_unique( + juce::ParameterID{"arpEnabled", 1}, "Arp On", + juce::StringArray{"Off", "On"}, 0)); + layout.add(std::make_unique( + juce::ParameterID{"arpPattern", 1}, "Arp Pattern", + juce::StringArray{"Up", "Down", "UpDown", "DownUp", "Random", "As Played", "Chord"}, 0)); + layout.add(std::make_unique( + juce::ParameterID{"arpOctaves", 1}, "Arp Octaves", + juce::StringArray{"1", "2", "3"}, 1)); + layout.add(std::make_unique( + juce::ParameterID{"arpDirection", 1}, "Arp Direction", + juce::StringArray{"Up", "Down"}, 0)); + layout.add(std::make_unique( + juce::ParameterID{"arpRate", 1}, "Arp Rate", + juce::StringArray{"1/16", "1/8", "1/4", "1/2", "1", "2"}, 1)); + return layout; } @@ -286,6 +303,9 @@ void ChromaFlockProcessor::prepareToPlay(double sampleRate, int samplesPerBlock) delay.prepare(sampleRate); reverbFX.prepare(sampleRate); autoPanPhase = 0.0f; + arpSampleCount = 0.0; + std::vector arpStop; + arp.reset(arpStop); updateVoiceParameters(); } @@ -383,19 +403,85 @@ void ChromaFlockProcessor::processBlock(juce::AudioBuffer& buffer, juce:: buffer.clear(); updateVoiceParameters(); - for (const auto metadata : midiMessages) - if (metadata.getMessage().isNoteOn()) - activeNotes[metadata.getMessage().getNoteNumber()].store(true, std::memory_order_relaxed); - else if (metadata.getMessage().isNoteOff()) - activeNotes[metadata.getMessage().getNoteNumber()].store(false, std::memory_order_relaxed); + auto getRaw = [&](const juce::String& id) -> float { + auto* p = apvts.getRawParameterValue(id); + return p != nullptr ? p->load() : 0.0f; + }; + + bool arpOn = getRaw("arpEnabled") > 0.5f; + if (arpOn) { + static const double arpRateBeats[] = {0.25, 0.5, 1.0, 2.0, 4.0, 8.0}; + int rateIdx = juce::jlimit(0, 5, juce::roundToInt(getRaw("arpRate"))); + arp.setParameters(true, + juce::roundToInt(getRaw("arpPattern")), + juce::roundToInt(getRaw("arpOctaves")) + 1, + juce::roundToInt(getRaw("arpDirection")), + arpRateBeats[rateIdx], + currentBpm); + } else { + arp.setParameters(false, 0, 1, 0, 0.5, currentBpm); + } int transpose = getTransposeSemitones(); juce::MidiBuffer transposed; for (const auto metadata : midiMessages) { auto msg = metadata.getMessage(); - if (msg.isNoteOn() || msg.isNoteOff()) - msg.setNoteNumber(juce::jlimit(0, 127, msg.getNoteNumber() + transpose)); - transposed.addEvent(msg, metadata.samplePosition); + if (msg.isNoteOn()) { + int note = msg.getNoteNumber(); + activeNotes[note].store(true, std::memory_order_relaxed); + if (arpOn) + arp.noteOn(note, msg.getFloatVelocity()); + else { + msg.setNoteNumber(juce::jlimit(0, 127, note + transpose)); + transposed.addEvent(msg, metadata.samplePosition); + } + } else if (msg.isNoteOff()) { + int note = msg.getNoteNumber(); + activeNotes[note].store(false, std::memory_order_relaxed); + if (arpOn) + arp.noteOff(note); + else { + msg.setNoteNumber(juce::jlimit(0, 127, note + transpose)); + transposed.addEvent(msg, metadata.samplePosition); + } + } else { + transposed.addEvent(msg, metadata.samplePosition); + } + } + + if (arpOn) { + // A freshly pressed key triggers the first note immediately; the + // clock then starts from zero so the subsequent ticks stay synced. + if (arp.shouldTriggerNow()) { + std::vector stopNotes; + std::vector playNotes; + arp.step(stopNotes, playNotes); + for (int n : stopNotes) + synth.noteOff(1, juce::jlimit(0, 127, n + transpose), 0.0f, true); + for (const auto& np : playNotes) + synth.noteOn(1, juce::jlimit(0, 127, np.note + transpose), np.velocity); + arpSampleCount = 0.0; + } + + double tickSamples = arp.getTickSeconds() * currentSampleRate; + if (tickSamples < 1.0) tickSamples = 1.0; + arpSampleCount += buffer.getNumSamples(); + while (arpSampleCount >= tickSamples) { + arpSampleCount -= tickSamples; + std::vector stopNotes; + std::vector playNotes; + arp.step(stopNotes, playNotes); + for (int n : stopNotes) + synth.noteOff(1, juce::jlimit(0, 127, n + transpose), 0.0f, true); + for (const auto& np : playNotes) + synth.noteOn(1, juce::jlimit(0, 127, np.note + transpose), np.velocity); + } + } else { + arpSampleCount = 0.0; + std::vector stopNotes; + arp.reset(stopNotes); + for (int n : stopNotes) + synth.noteOff(1, juce::jlimit(0, 127, n + transpose), 0.0f, true); } synth.renderNextBlock(buffer, transposed, 0, buffer.getNumSamples()); diff --git a/Source/PluginProcessor.h b/Source/PluginProcessor.h index 31f9dd2..367dd66 100644 --- a/Source/PluginProcessor.h +++ b/Source/PluginProcessor.h @@ -1,8 +1,8 @@ #pragma once #include #include -#include #include "DSP/Voice.h" +#include "DSP/Arpeggiator.h" #include "DSP/Distortion.h" #include "DSP/Compressor.h" #include "DSP/Limiter.h" @@ -53,17 +53,30 @@ public: std::array fftInput{}; std::atomic fftWritePos{0}; + Arpeggiator arp; + float getRmsLevel() const { return rmsLevel.load(); } + bool isArpEnabled() const { + auto* p = apvts.getRawParameterValue("arpEnabled"); + return p != nullptr && p->load() > 0.5f; + } + void noteOn(int midiNote, float velocity) { if (midiNote >= 0 && midiNote < 128) activeNotes[midiNote].store(true, std::memory_order_relaxed); - synth.noteOn(1, juce::jlimit(0, 127, midiNote + getTransposeSemitones()), velocity); + if (isArpEnabled()) + arp.noteOn(midiNote, velocity); + else + synth.noteOn(1, juce::jlimit(0, 127, midiNote + getTransposeSemitones()), velocity); } void noteOff(int midiNote) { if (midiNote >= 0 && midiNote < 128) activeNotes[midiNote].store(false, std::memory_order_relaxed); - synth.noteOff(1, juce::jlimit(0, 127, midiNote + getTransposeSemitones()), 0.0f, true); + if (isArpEnabled()) + arp.noteOff(midiNote); + else + synth.noteOff(1, juce::jlimit(0, 127, midiNote + getTransposeSemitones()), 0.0f, true); } bool isNoteActive(int midiNote) const { return midiNote >= 0 && midiNote < 128 @@ -102,6 +115,7 @@ private: double currentSampleRate = 44100.0; double currentBpm = 120.0; + double arpSampleCount = 0.0; std::atomic rmsLevel{0.0f}; std::array, 128> activeNotes{}; diff --git a/Source/PresetManager.h b/Source/PresetManager.h index 293e13f..0123fc5 100644 --- a/Source/PresetManager.h +++ b/Source/PresetManager.h @@ -60,14 +60,14 @@ private: void buildPresets() { // --- DEFAULT --- - add("Init", "Init", { + add("Zero State", "Init", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.2f}, {"filterEnvAmt", 0}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.01f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.03f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.5f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.981f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 4}, {"compAttack", 10}, {"compRelease", 100}, {"compMakeup", 0}, @@ -80,14 +80,14 @@ private: }); // --- BASS --- - add("Sub Bass", "Bass", { + add("Sub Cortex", "Bass", { {"osc1Wave", 0}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 150}, {"filterRes", 0.2f}, {"filterEnvAmt", 0}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.01f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.005f}, {"envDecay", 0.4f}, {"envSustain", 0.7f}, {"envRelease", 0.3f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.679}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.777}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 6}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 4}, @@ -99,14 +99,14 @@ private: {"reverbSize", 0.5f}, {"reverbDamping", 0.5f}, {"reverbMix", 0} }); - add("Reese Bass", "Bass", { + add("Neuro Flux", "Bass", { {"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", -7}, {"osc2Fine", 15}, {"osc2Level", 0.7f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.01f}, {"fEnvDecay", 0.5f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.005f}, {"envDecay", 0.3f}, {"envSustain", 0.8f}, {"envRelease", 0.4f}, - {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.445}, + {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.657}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 4}, {"compAttack", 8}, {"compRelease", 100}, {"compMakeup", 3}, @@ -118,16 +118,16 @@ private: {"reverbSize", 0.5f}, {"reverbDamping", 0.5f}, {"reverbMix", 0} }); - add("Acid Bass", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.85f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.4f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.531}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -20}, {"compRatio", 5}, {"compAttack", 5}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0}, {"delayMix", 0}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.5f}, {"reverbMix", 0}}}); + add("Acid Vector", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.85f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.4f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.904}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -20}, {"compRatio", 5}, {"compAttack", 5}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0}, {"delayMix", 0}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.5f}, {"reverbMix", 0}}}); - add("Pluck Bass", "Bass", { + add("Transient Core", "Bass", { {"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.1f}, {"envRelease", 0.1f}, - {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 4}, {"compAttack", 3}, {"compRelease", 50}, {"compMakeup", 2}, @@ -139,16 +139,16 @@ private: {"reverbSize", 0.5f}, {"reverbDamping", 0.5f}, {"reverbMix", 0} }); - add("Moog Bass", "Bass", {{{"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 250}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.25f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 1.6f}, {"masterLevel", 0.483}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 5}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 4}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0}, {"lfo1Depth", 0}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.15f}, {"delayMix", 0.1f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.05f}}}); + add("Analog Cell", "Bass", {{{"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 250}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.25f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 1.6f}, {"masterLevel", 0.682}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 5}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 4}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0}, {"lfo1Depth", 0}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.15f}, {"delayMix", 0.1f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.05f}}}); - add("Gritty Bass", "Bass", { + add("Static Drive", "Bass", { {"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 12}, {"osc2Level", 0.5f}, {"phaseOffset", 0.4f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.6f}, {"envRelease", 0.15f}, - {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 0.359}, + {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 0.625}, {"pitchBendRange", 2}, {"distType", 2}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 50}, {"compMakeup", 5}, @@ -160,14 +160,14 @@ private: {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f} }); - add("FM Bass", "Bass", { + add("Sideband Core", "Bass", { {"osc1Wave", 0}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", 2}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.5f}, {"envRelease", 0.1f}, - {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.539}, + {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.826}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 4}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 3}, @@ -180,23 +180,23 @@ private: }); // --- LEAD --- - add("Sync Lead", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.475}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Sync Engine", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.651}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); - add("Square Lead", "Lead", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 5}, {"osc2Fine", 10}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3500}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.696}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Block Signal", "Lead", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 5}, {"osc2Fine", 10}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3500}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.609}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); - add("Soft Lead", "Lead", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.25f}, {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.8f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.5f}, {"lfo1Depth", 0.08f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.08f}}}); + add("Soft Emitter", "Lead", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.25f}, {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.795f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.5f}, {"lfo1Depth", 0.08f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.08f}}}); - add("Saw Lead", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.35f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 4000}, {"filterRes", 0.35f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.565}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.12f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.8f}, {"lfo2Depth", 0.1f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.18f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.06f}}}); + add("Saw Beam", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.35f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 4000}, {"filterRes", 0.35f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.671}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.12f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.8f}, {"lfo2Depth", 0.1f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.18f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.06f}}}); // --- PAD --- - add("Warm Pad", "Pad", { + add("Thermal Haze", "Pad", { {"osc1Wave", 16}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 12}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.5f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 2.0f}, {"envAttack", 1.5f}, {"envDecay", 1.0f}, {"envSustain", 0.8f}, {"envRelease", 3.0f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.696f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 2}, {"compAttack", 20}, {"compRelease", 200}, {"compMakeup", 2}, @@ -208,14 +208,14 @@ private: {"reverbSize", 0.7f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.3f} }); - add("Glass Pad", "Pad", { + add("Glass Prism", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.05f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.8f}, {"fEnvDecay", 1.5f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 2.5f}, {"envAttack", 2.0f}, {"envDecay", 1.5f}, {"envSustain", 0.7f}, {"envRelease", 4.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.634f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 250}, {"compMakeup", 3}, @@ -227,14 +227,14 @@ private: {"reverbSize", 0.8f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.35f} }); - add("Dark Pad", "Pad", { + add("Void Wash", "Pad", { {"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 15}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 250}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.15f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.3f}, {"fEnvDecay", 0.8f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 1.5f}, {"envAttack", 1.0f}, {"envDecay", 0.8f}, {"envSustain", 0.8f}, {"envRelease", 3.0f}, - {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.676f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 15}, {"compRelease", 150}, {"compMakeup", 2}, @@ -246,14 +246,14 @@ private: {"reverbSize", 0.85f}, {"reverbDamping", 0.25f}, {"reverbMix", 0.4f} }); - add("Shimmer Pad", "Pad", { + add("Shimmer Grid", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.4f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.6f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.5f}, {"envDecay", 2.0f}, {"envSustain", 0.9f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.454f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 25}, {"compRelease", 200}, {"compMakeup", 3}, @@ -265,14 +265,14 @@ private: {"reverbSize", 0.9f}, {"reverbDamping", 0.15f}, {"reverbMix", 0.5f} }); - add("Evolving Pad", "Pad", { + add("Morph Vector", "Pad", { {"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -5}, {"osc1Level", 0.5f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 8}, {"osc2Level", 0.5f}, {"phaseOffset", 0.2f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.4f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.5f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 4.0f}, {"envAttack", 3.0f}, {"envDecay", 2.0f}, {"envSustain", 0.85f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 0.566f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -22}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 300}, {"compMakeup", 2}, @@ -284,14 +284,14 @@ private: {"reverbSize", 0.9f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.45f} }); - add("Choir Pad", "Pad", { + add("Vocal Matrix", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", -3}, {"osc2Level", 0.4f}, {"phaseOffset", 0.1f}, {"filterType", 0}, {"filterCutoff", 700}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.05f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.8f}, {"fEnvDecay", 1.2f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 2.0f}, {"envAttack", 1.2f}, {"envDecay", 1.0f}, {"envSustain", 0.85f}, {"envRelease", 3.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.75f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.679f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -22}, {"compRatio", 2}, {"compAttack", 25}, {"compRelease", 250}, {"compMakeup", 3}, @@ -304,14 +304,14 @@ private: }); // --- KEYS --- - add("Electric Piano", "Keys", { + add("Delta Keys", "Keys", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.5f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.001f}, {"envDecay", 0.5f}, {"envSustain", 0.3f}, {"envRelease", 0.8f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.846f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 3}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 2}, @@ -323,16 +323,16 @@ private: {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.15f} }); - add("Organ", "Keys", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 2}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.1f}, {"filterEnvAmt", 0}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.9f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.9f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 8}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.05f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0}, {"delayMix", 0}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); + add("Tonewheel Array", "Keys", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 2}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.1f}, {"filterEnvAmt", 0}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.9f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.9f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.794f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 8}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.05f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0}, {"delayMix", 0}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); - add("Clav", "Keys", { + add("Funk Circuit", "Keys", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 700}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.05f}, {"envRelease", 0.1f}, - {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.926f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 4}, {"compAttack", 5}, {"compRelease", 60}, {"compMakeup", 3}, @@ -344,14 +344,14 @@ private: {"reverbSize", 0.25f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f} }); - add("Rhodes", "Keys", { + add("Tine Module", "Keys", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.65f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 5}, {"osc2Level", 0.35f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 650}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.15f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.6f}, {"fEnvSustain", 0.25f}, {"fEnvRelease", 0.7f}, {"envAttack", 0.001f}, {"envDecay", 0.6f}, {"envSustain", 0.25f}, {"envRelease", 1.0f}, - {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 8}, {"compRelease", 100}, {"compMakeup", 2}, @@ -363,14 +363,14 @@ private: {"reverbSize", 0.55f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.25f} }); - add("Bell Keys", "Keys", { + add("Bell Matrix", "Keys", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 3}, {"osc2Level", 0.4f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 900}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.05f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.8f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 1.5f}, {"envAttack", 0.001f}, {"envDecay", 0.8f}, {"envSustain", 0.0f}, {"envRelease", 2.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.75f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.966f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 2}, {"compAttack", 15}, {"compRelease", 150}, {"compMakeup", 2}, @@ -382,14 +382,14 @@ private: {"reverbSize", 0.75f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.35f} }); - add("Toy Piano", "Keys", { + add("Toy Engine", "Keys", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 12}, {"osc1Level", 0.5f}, {"osc2Wave", 2}, {"osc2Oct", 2}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1100}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.0f}, {"envRelease", 0.3f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.996f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 2}, @@ -402,38 +402,38 @@ private: }); // --- FX --- - add("Wobble", "FX1", {{{"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.005f}, {"envDecay", 0.3f}, {"envSustain", 0.8f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.442}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 5}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 4}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.7f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 8.0f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 200}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.15f}}}); + add("Wobble Cell", "FX1", {{{"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.005f}, {"envDecay", 0.3f}, {"envSustain", 0.8f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.618}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 5}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 4}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.7f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 8.0f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 200}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.15f}}}); - add("Distorted Lead", "FX1", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.005f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.005f}, {"envDecay", 0.2f}, {"envSustain", 0.8f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.269}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -20}, {"compRatio", 4}, {"compAttack", 8}, {"compRelease", 100}, {"compMakeup", 6}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.1f}}}); + add("Distortion Beam", "FX1", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.005f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.005f}, {"envDecay", 0.2f}, {"envSustain", 0.8f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.734}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -20}, {"compRatio", 4}, {"compAttack", 8}, {"compRelease", 100}, {"compMakeup", 6}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.1f}}}); - add("Auto-Pan Spread", "FX1", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.1f}, {"filterEnvAmt", 0}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.01f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.01f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.5f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 3}, {"compAttack", 10}, {"compRelease", 100}, {"compMakeup", 2}, {"autoPanRate", 2.0f}, {"autoPanDepth", 0.8f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.3f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.15f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 300}, {"delayFeedback", 0.25f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.15f}}}); + add("Pan Matrix", "FX1", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.1f}, {"filterEnvAmt", 0}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.01f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.01f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.5f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 3}, {"compAttack", 10}, {"compRelease", 100}, {"compMakeup", 2}, {"autoPanRate", 2.0f}, {"autoPanDepth", 0.8f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.3f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.15f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 300}, {"delayFeedback", 0.25f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.15f}}}); - add("Filtered Noise", "FX1", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 400}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.5f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.01f}, {"envDecay", 0.5f}, {"envSustain", 0.5f}, {"envRelease", 1.0f}, {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.528}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 4}, {"compAttack", 5}, {"compRelease", 100}, {"compMakeup", 4}, {"autoPanRate", 0.5f}, {"autoPanDepth", 0.6f}, {"autoPanPhase", 0}, {"lfo1Rate", 2.5f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.4f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.35f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.6f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.25f}}}); + add("Filtered Static", "FX1", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 400}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.5f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.01f}, {"envDecay", 0.5f}, {"envSustain", 0.5f}, {"envRelease", 1.0f}, {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 4}, {"compAttack", 5}, {"compRelease", 100}, {"compMakeup", 4}, {"autoPanRate", 0.5f}, {"autoPanDepth", 0.6f}, {"autoPanPhase", 0}, {"lfo1Rate", 2.5f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.4f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.35f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.6f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.25f}}}); - add("Dub Delay", "FX2", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.7f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.64}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 4}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 3}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0}, {"lfo1Depth", 0}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 500}, {"delayFeedback", 0.7f}, {"delayMix", 0.4f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.6f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.3f}}}); + add("Echo Buffer", "FX2", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.7f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.93}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 4}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 3}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0}, {"lfo1Depth", 0}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 500}, {"delayFeedback", 0.7f}, {"delayMix", 0.4f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.6f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.3f}}}); - add("Reverse Reverb", "FX2", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.5f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 2.0f}, {"envAttack", 0.3f}, {"envDecay", 0.8f}, {"envSustain", 0.6f}, {"envRelease", 1.5f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.65f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 2}, {"compAttack", 20}, {"compRelease", 200}, {"compMakeup", 2}, {"autoPanRate", 0.3f}, {"autoPanDepth", 0.3f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.1f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 800}, {"delayFeedback", 0.6f}, {"delayMix", 0.5f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.95f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.6f}}}); + add("Reverse Wash", "FX2", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.5f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 2.0f}, {"envAttack", 0.3f}, {"envDecay", 0.8f}, {"envSustain", 0.6f}, {"envRelease", 1.5f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.325f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 2}, {"compAttack", 20}, {"compRelease", 200}, {"compMakeup", 2}, {"autoPanRate", 0.3f}, {"autoPanDepth", 0.3f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.1f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 800}, {"delayFeedback", 0.6f}, {"delayMix", 0.5f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.95f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.6f}}}); - add("Laser Zap", "FX2", {{{"osc1Wave", 1}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 200}, {"filterRes", 0.9f}, {"filterEnvAmt", 1.0f}, {"keyTrack", 0}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.0f}, {"envRelease", 0.05f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.45}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 5}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 5}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 12.0f}, {"lfo1Depth", 0.8f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 100}, {"delayFeedback", 0.4f}, {"delayMix", 0.25f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.2f}}}); + add("Laser Pulse", "FX2", {{{"osc1Wave", 1}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 200}, {"filterRes", 0.9f}, {"filterEnvAmt", 1.0f}, {"keyTrack", 0}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.0f}, {"envRelease", 0.05f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 5}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 5}, {"autoPanRate", 2}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 12.0f}, {"lfo1Depth", 0.8f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 100}, {"delayFeedback", 0.4f}, {"delayMix", 0.25f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.2f}}}); - add("Space Drone", "FX2", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -7}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.1f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.3f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 5.0f}, {"envAttack", 3.0f}, {"envDecay", 2.0f}, {"envSustain", 0.9f}, {"envRelease", 6.0f}, {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 0.6f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 40}, {"compRelease", 500}, {"compMakeup", 3}, {"autoPanRate", 0.1f}, {"autoPanDepth", 0.6f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.08f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 4}, {"lfo2Rate", 0.02f}, {"lfo2Depth", 0.25f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 900}, {"delayFeedback", 0.75f}, {"delayMix", 0.5f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.7f}}}); + add("Orbital Drone", "FX2", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -7}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.1f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.3f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 5.0f}, {"envAttack", 3.0f}, {"envDecay", 2.0f}, {"envSustain", 0.9f}, {"envRelease", 6.0f}, {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 0.439f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 40}, {"compRelease", 500}, {"compMakeup", 3}, {"autoPanRate", 0.1f}, {"autoPanDepth", 0.6f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.08f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 4}, {"lfo2Rate", 0.02f}, {"lfo2Depth", 0.25f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 900}, {"delayFeedback", 0.75f}, {"delayMix", 0.5f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.7f}}}); - add("Ring Mod", "FX2", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 3}, {"osc2Semi", 5}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.457}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 4}, {"compAttack", 3}, {"compRelease", 50}, {"compMakeup", 4}, {"autoPanRate", 3.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 7.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 11.0f}, {"lfo2Depth", 0.4f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.3f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); + add("Ring Logic", "FX2", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 3}, {"osc2Semi", 5}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.836}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 4}, {"compAttack", 3}, {"compRelease", 50}, {"compMakeup", 4}, {"autoPanRate", 3.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 7.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 11.0f}, {"lfo2Depth", 0.4f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.3f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); - add("Glitch Stutter", "FX2", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 1}, {"filterCutoff", 600}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.2f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.05f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.03f}, {"envAttack", 0.001f}, {"envDecay", 0.05f}, {"envSustain", 0.0f}, {"envRelease", 0.03f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.328}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 8}, {"compAttack", 1}, {"compRelease", 20}, {"compMakeup", 6}, {"autoPanRate", 8.0f}, {"autoPanDepth", 0.8f}, {"autoPanPhase", 0}, {"lfo1Rate", 15.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.5f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 60}, {"delayFeedback", 0.5f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.15f}}}); + add("Glitch Buffer", "FX2", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 1}, {"filterCutoff", 600}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.2f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.05f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.03f}, {"envAttack", 0.001f}, {"envDecay", 0.05f}, {"envSustain", 0.0f}, {"envRelease", 0.03f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 8}, {"compAttack", 1}, {"compRelease", 20}, {"compMakeup", 6}, {"autoPanRate", 8.0f}, {"autoPanDepth", 0.8f}, {"autoPanPhase", 0}, {"lfo1Rate", 15.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.5f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 60}, {"delayFeedback", 0.5f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.15f}}}); // ======== INSANITY ======== - add("Alien Swarm", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 17}, {"osc1Level", 0.7f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", -13}, {"osc2Level", 0.6f}, {"phaseOffset", 0.73f}, {"filterType", 3}, {"filterCutoff", 900}, {"filterRes", 0.95f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.6f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 0.351}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 5}, {"autoPanRate", 7.0f}, {"autoPanDepth", 0.9f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.8f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 3}, {"lfo1Dest", 4}, {"lfo2Rate", 19.0f}, {"lfo2Depth", 0.7f}, {"lfo2Shape", 3}, {"lfo2Dest", 1}, {"delayTime", 47}, {"delayFeedback", 0.6f}, {"delayMix", 0.35f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.7f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.4f}}}); + add("Alien Protocol", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 17}, {"osc1Level", 0.7f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", -13}, {"osc2Level", 0.6f}, {"phaseOffset", 0.73f}, {"filterType", 3}, {"filterCutoff", 900}, {"filterRes", 0.95f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.6f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 5}, {"autoPanRate", 7.0f}, {"autoPanDepth", 0.9f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.8f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 3}, {"lfo1Dest", 4}, {"lfo2Rate", 19.0f}, {"lfo2Depth", 0.7f}, {"lfo2Shape", 3}, {"lfo2Dest", 1}, {"delayTime", 47}, {"delayFeedback", 0.6f}, {"delayMix", 0.35f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.7f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.4f}}}); - add("Nuclear Siren", "Insanity", { + add("Siren Core", "Insanity", { {"osc1Wave", 1}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 1}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", 5}, {"osc2Level", 0.7f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.9f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.8f}, {"fEnvDecay", 1.5f}, {"fEnvSustain", 0.8f}, {"fEnvRelease", 2.0f}, {"envAttack", 0.01f}, {"envDecay", 0.3f}, {"envSustain", 0.9f}, {"envRelease", 1.0f}, - {"pan", 0}, {"drive", 4.0f}, {"masterLevel", 0.369}, + {"pan", 0}, {"drive", 4.0f}, {"masterLevel", 0.624}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -10}, {"compRatio", 8}, {"compAttack", 1}, {"compRelease", 60}, {"compMakeup", 3}, @@ -445,22 +445,22 @@ private: {"reverbSize", 0.8f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.35f} }); - add("Death Ray", "Insanity", {{{"osc1Wave", 2}, {"osc1Oct", 3}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 3}, {"filterCutoff", 200}, {"filterRes", 1.0f}, {"filterEnvAmt", 1.0f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.05f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.02f}, {"envAttack", 0.001f}, {"envDecay", 0.08f}, {"envSustain", 0.0f}, {"envRelease", 0.02f}, {"pan", 0}, {"drive", 5.0f}, {"masterLevel", 0.248}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -8}, {"compRatio", 12}, {"compAttack", 0.5f}, {"compRelease", 15}, {"compMakeup", 8}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 20.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 25}, {"delayFeedback", 0.8f}, {"delayMix", 0.4f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.15f}}}); + add("Plasma Ray", "Insanity", {{{"osc1Wave", 2}, {"osc1Oct", 3}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 3}, {"filterCutoff", 200}, {"filterRes", 1.0f}, {"filterEnvAmt", 1.0f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.05f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.02f}, {"envAttack", 0.001f}, {"envDecay", 0.08f}, {"envSustain", 0.0f}, {"envRelease", 0.02f}, {"pan", 0}, {"drive", 5.0f}, {"masterLevel", 0.499}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -8}, {"compRatio", 12}, {"compAttack", 0.5f}, {"compRelease", 15}, {"compMakeup", 8}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 20.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 25}, {"delayFeedback", 0.8f}, {"delayMix", 0.4f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.15f}}}); - add("Toxic Waste", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 6}, {"osc2Fine", 23}, {"osc2Level", 0.7f}, {"phaseOffset", 0.37f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.92f}, {"filterEnvAmt", 0.85f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.15f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.5f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 4.5f}, {"masterLevel", 0.249}, {"pitchBendRange", 2}, {"distType", 2}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 10}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 6}, {"autoPanRate", 5.0f}, {"autoPanDepth", 0.7f}, {"autoPanPhase", 0}, {"lfo1Rate", 6.5f}, {"lfo1Depth", 0.8f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 11.0f}, {"lfo2Depth", 0.5f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 73}, {"delayFeedback", 0.55f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); + add("Toxin Core", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 6}, {"osc2Fine", 23}, {"osc2Level", 0.7f}, {"phaseOffset", 0.37f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.92f}, {"filterEnvAmt", 0.85f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.15f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.5f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 4.5f}, {"masterLevel", 0.75}, {"pitchBendRange", 2}, {"distType", 2}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 10}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 6}, {"autoPanRate", 5.0f}, {"autoPanDepth", 0.7f}, {"autoPanPhase", 0}, {"lfo1Rate", 6.5f}, {"lfo1Depth", 0.8f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 11.0f}, {"lfo2Depth", 0.5f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 73}, {"delayFeedback", 0.55f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); - add("Broken Radio", "Insanity", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 3}, {"osc2Fine", 37}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 600}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.1f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.4f}, {"envRelease", 0.08f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.389}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 8}, {"compAttack", 2}, {"compRelease", 25}, {"compMakeup", 5}, {"autoPanRate", 12.0f}, {"autoPanDepth", 0.8f}, {"autoPanPhase", 0}, {"lfo1Rate", 17.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0.3f}, {"lfo2Depth", 0.9f}, {"lfo2Shape", 2}, {"lfo2Dest", 1}, {"delayTime", 33}, {"delayFeedback", 0.7f}, {"delayMix", 0.35f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.25f}}}); + add("Fractured Signal", "Insanity", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 3}, {"osc2Fine", 37}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 600}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.1f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.4f}, {"envRelease", 0.08f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.932}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 8}, {"compAttack", 2}, {"compRelease", 25}, {"compMakeup", 5}, {"autoPanRate", 12.0f}, {"autoPanDepth", 0.8f}, {"autoPanPhase", 0}, {"lfo1Rate", 17.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0.3f}, {"lfo2Depth", 0.9f}, {"lfo2Shape", 2}, {"lfo2Dest", 1}, {"delayTime", 33}, {"delayFeedback", 0.7f}, {"delayMix", 0.35f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.25f}}}); - add("Flesh Wound", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -8}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 1}, {"osc2Fine", 11}, {"osc2Level", 0.8f}, {"phaseOffset", 0.42f}, {"filterType", 1}, {"filterCutoff", 500}, {"filterRes", 0.85f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.7f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 5.0f}, {"masterLevel", 0.16}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -10}, {"compRatio", 10}, {"compAttack", 0.5f}, {"compRelease", 20}, {"compMakeup", 8}, {"autoPanRate", 3.0f}, {"autoPanDepth", 0.6f}, {"autoPanPhase", 0}, {"lfo1Rate", 8.0f}, {"lfo1Depth", 0.7f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 14.0f}, {"lfo2Depth", 0.4f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 55}, {"delayFeedback", 0.4f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.1f}}}); + add("Biomech Scar", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -8}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 1}, {"osc2Fine", 11}, {"osc2Level", 0.8f}, {"phaseOffset", 0.42f}, {"filterType", 1}, {"filterCutoff", 500}, {"filterRes", 0.85f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.7f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 5.0f}, {"masterLevel", 0.522}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -10}, {"compRatio", 10}, {"compAttack", 0.5f}, {"compRelease", 20}, {"compMakeup", 8}, {"autoPanRate", 3.0f}, {"autoPanDepth", 0.6f}, {"autoPanPhase", 0}, {"lfo1Rate", 8.0f}, {"lfo1Depth", 0.7f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 14.0f}, {"lfo2Depth", 0.4f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 55}, {"delayFeedback", 0.4f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.1f}}}); - add("Junkyard Dog", "Insanity", { + add("Scrap Hound", "Insanity", { {"osc1Wave", 1}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 4}, {"osc2Fine", -19}, {"osc2Level", 0.7f}, {"phaseOffset", 0.15f}, {"filterType", 0}, {"filterCutoff", 250}, {"filterRes", 0.7f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.6f}, {"envRelease", 0.2f}, - {"pan", 0}, {"drive", 4.8f}, {"masterLevel", 0.2}, + {"pan", 0}, {"drive", 4.8f}, {"masterLevel", 0.413}, {"pitchBendRange", 2}, {"distType", 2}, {"distAmount", 0}, {"compThreshold", -8}, {"compRatio", 12}, {"compAttack", 1}, {"compRelease", 25}, {"compMakeup", 7}, @@ -472,22 +472,22 @@ private: {"reverbSize", 0.15f}, {"reverbDamping", 0.9f}, {"reverbMix", 0.05f} }); - add("Pixel Storm", "Insanity", {{{"osc1Wave", 2}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 1}, {"filterCutoff", 800}, {"filterRes", 0.95f}, {"filterEnvAmt", 1.0f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.03f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.02f}, {"envAttack", 0.001f}, {"envDecay", 0.04f}, {"envSustain", 0.0f}, {"envRelease", 0.02f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.347}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 10}, {"compAttack", 0.5f}, {"compRelease", 10}, {"compMakeup", 6}, {"autoPanRate", 20.0f}, {"autoPanDepth", 1.0f}, {"autoPanPhase", 0}, {"lfo1Rate", 20.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 15.0f}, {"lfo2Depth", 0.8f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 20}, {"delayFeedback", 0.6f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); + add("Pixel Storm", "Insanity", {{{"osc1Wave", 2}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 1}, {"filterCutoff", 800}, {"filterRes", 0.95f}, {"filterEnvAmt", 1.0f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.03f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.02f}, {"envAttack", 0.001f}, {"envDecay", 0.04f}, {"envSustain", 0.0f}, {"envRelease", 0.02f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 10}, {"compAttack", 0.5f}, {"compRelease", 10}, {"compMakeup", 6}, {"autoPanRate", 20.0f}, {"autoPanDepth", 1.0f}, {"autoPanPhase", 0}, {"lfo1Rate", 20.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 15.0f}, {"lfo2Depth", 0.8f}, {"lfo2Shape", 3}, {"lfo2Dest", 3}, {"delayTime", 20}, {"delayFeedback", 0.6f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); - add("Venom", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 3}, {"osc1Level", 0.85f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", -5}, {"osc2Level", 0.6f}, {"phaseOffset", 0.28f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.98f}, {"filterEnvAmt", 0.95f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.65f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 3.8f}, {"masterLevel", 0.3}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 8}, {"compAttack", 2}, {"compRelease", 35}, {"compMakeup", 5}, {"autoPanRate", 4.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.85f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 9.0f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 1}, {"delayTime", 66}, {"delayFeedback", 0.5f}, {"delayMix", 0.25f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.45f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); + add("Venom Vector", "Insanity", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 3}, {"osc1Level", 0.85f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", -5}, {"osc2Level", 0.6f}, {"phaseOffset", 0.28f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.98f}, {"filterEnvAmt", 0.95f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.65f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 3.8f}, {"masterLevel", 0.755}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 8}, {"compAttack", 2}, {"compRelease", 35}, {"compMakeup", 5}, {"autoPanRate", 4.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.85f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 9.0f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 1}, {"delayTime", 66}, {"delayFeedback", 0.5f}, {"delayMix", 0.25f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.45f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); - add("Screaming Eagle", "Insanity", {{{"osc1Wave", 0}, {"osc1Oct", 3}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", 3}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 3}, {"filterCutoff", 1200}, {"filterRes", 0.9f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.5f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.425}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 30}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 10.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 0}, {"lfo1Dest", 1}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 40}, {"delayFeedback", 0.7f}, {"delayMix", 0.4f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.6f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.3f}}}); + add("Eagle Protocol", "Insanity", {{{"osc1Wave", 0}, {"osc1Oct", 3}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", 3}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 3}, {"filterCutoff", 1200}, {"filterRes", 0.9f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.5f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.735}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 30}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 10.0f}, {"lfo1Depth", 1.0f}, {"lfo1Shape", 0}, {"lfo1Dest", 1}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 40}, {"delayFeedback", 0.7f}, {"delayMix", 0.4f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.6f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.3f}}}); // ======== TEXTURES ======== - add("Frozen Lake", "Textures", { + add("Cryo Field", "Textures", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", -3}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 4}, {"osc2Level", 0.5f}, {"phaseOffset", 0.67f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.05f}, {"keyTrack", 0.6f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 5.0f}, {"envAttack", 3.0f}, {"envDecay", 2.0f}, {"envSustain", 0.8f}, {"envRelease", 6.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.346f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -30}, {"compRatio", 1.5f}, {"compAttack", 40}, {"compRelease", 500}, {"compMakeup", 2}, @@ -499,14 +499,14 @@ private: {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.7f} }); - add("Volcanic Ash", "Textures", { + add("Pyro Static", "Textures", { {"osc1Wave", 4}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 1}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 200}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.2f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.0f}, {"envDecay", 1.5f}, {"envSustain", 0.7f}, {"envRelease", 4.0f}, - {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.499f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -20}, {"compRatio", 3}, {"compAttack", 20}, {"compRelease", 200}, {"compMakeup", 2}, @@ -518,14 +518,14 @@ private: {"reverbSize", 0.85f}, {"reverbDamping", 0.15f}, {"reverbMix", 0.5f} }); - add("Iron Lung", "Textures", { + add("Pneumatic Core", "Textures", { {"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 5}, {"osc2Fine", -3}, {"osc2Level", 0.5f}, {"phaseOffset", 0.4f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.3f}, {"fEnvAttack", 3.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 4.0f}, {"envAttack", 2.5f}, {"envDecay", 1.5f}, {"envSustain", 0.8f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.564f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 400}, {"compMakeup", 2}, @@ -537,14 +537,14 @@ private: {"reverbSize", 0.8f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.45f} }); - add("Ghost Whisper", "Textures", { + add("Specter Wave", "Textures", { {"osc1Wave", 4}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.3f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", 15}, {"osc2Level", 0.2f}, {"phaseOffset", 0.8f}, {"filterType", 3}, {"filterCutoff", 400}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 3.0f}, {"envAttack", 4.0f}, {"envDecay", 1.0f}, {"envSustain", 0.2f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -30}, {"compRatio", 1.5f}, {"compAttack", 50}, {"compRelease", 600}, {"compMakeup", 4}, @@ -556,14 +556,14 @@ private: {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.8f} }); - add("Cosmic Dust", "Textures", { + add("Nebula Dust", "Textures", { {"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 0}, {"osc2Oct", 3}, {"osc2Semi", 0}, {"osc2Fine", 31}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 800}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.5f}, {"fEnvDecay", 1.5f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 2.0f}, {"envAttack", 1.0f}, {"envDecay", 1.0f}, {"envSustain", 0.6f}, {"envRelease", 3.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -28}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 300}, {"compMakeup", 3}, @@ -575,14 +575,14 @@ private: {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.75f} }); - add("Neon Dreams", "Textures", { + add("Neon Matrix", "Textures", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 5}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", -7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.33f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.8f}, {"fEnvDecay", 1.5f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 2.5f}, {"envAttack", 1.5f}, {"envDecay", 1.0f}, {"envSustain", 0.85f}, {"envRelease", 3.5f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.473f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -22}, {"compRatio", 2}, {"compAttack", 25}, {"compRelease", 250}, {"compMakeup", 3}, @@ -594,14 +594,14 @@ private: {"reverbSize", 0.9f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.55f} }); - add("Underwater", "Textures", { + add("Hydro Field", "Textures", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 3}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 180}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.4f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 4.0f}, {"envAttack", 1.5f}, {"envDecay", 1.0f}, {"envSustain", 0.7f}, {"envRelease", 3.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.809f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 300}, {"compMakeup", 2}, @@ -613,14 +613,14 @@ private: {"reverbSize", 0.8f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.5f} }); - add("Zen Garden", "Textures", { + add("Zen Module", "Textures", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 2}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 5}, {"osc2Fine", -2}, {"osc2Level", 0.4f}, {"phaseOffset", 0.6f}, {"filterType", 0}, {"filterCutoff", 700}, {"filterRes", 0.08f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.6f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.0f}, {"envDecay", 1.5f}, {"envSustain", 0.8f}, {"envRelease", 4.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.675f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -30}, {"compRatio", 1.5f}, {"compAttack", 40}, {"compRelease", 500}, {"compMakeup", 1}, @@ -632,14 +632,14 @@ private: {"reverbSize", 0.9f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.6f} }); - add("Synthetic Breath", "Textures", { + add("Synth Exhale", "Textures", { {"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.4f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 3}, {"filterCutoff", 300}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.0f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 1.5f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 2.0f}, {"envAttack", 2.0f}, {"envDecay", 1.0f}, {"envSustain", 0.5f}, {"envRelease", 3.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -28}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 400}, {"compMakeup", 3}, @@ -653,14 +653,14 @@ private: // ======== CHIPTUNE ======== - add("Power Up", "Chiptune", { + add("Power Surge", "Chiptune", { {"osc1Wave", 2}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 1.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.7f}, {"envRelease", 0.1f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.817}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.769}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 2}, @@ -672,16 +672,16 @@ private: {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.05f} }); - add("Boss Fight", "Chiptune", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.6f}, {"envRelease", 0.08f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.429}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 30}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 8.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 80}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f}}}); + add("Boss Protocol", "Chiptune", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.6f}, {"envRelease", 0.08f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.626}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 30}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 8.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 80}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f}}}); - add("Coin Drop", "Chiptune", { + add("Coin Cell", "Chiptune", { {"osc1Wave", 0}, {"osc1Oct", 2}, {"osc1Semi", 12}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", 3}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2000}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 1.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.0f}, {"envRelease", 0.08f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.765}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.978}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 30}, {"compMakeup", 3}, @@ -693,16 +693,16 @@ private: {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.1f} }); - add("16-Bit Blast", "Chiptune", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 3}, {"osc2Level", 0.7f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.06f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.04f}, {"envAttack", 0.001f}, {"envDecay", 0.08f}, {"envSustain", 0.5f}, {"envRelease", 0.06f}, {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.464}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 25}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 12.0f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 60}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.1f}, {"reverbDamping", 0.9f}, {"reverbMix", 0.03f}}}); + add("16-Bit Blast", "Chiptune", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 3}, {"osc2Level", 0.7f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.06f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.04f}, {"envAttack", 0.001f}, {"envDecay", 0.08f}, {"envSustain", 0.5f}, {"envRelease", 0.06f}, {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.68}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 25}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 12.0f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 60}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.1f}, {"reverbDamping", 0.9f}, {"reverbMix", 0.03f}}}); - add("Game Over", "Chiptune", { + add("Game Over State", "Chiptune", { {"osc1Wave", 2}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.5f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.3f}, {"envAttack", 0.001f}, {"envDecay", 0.8f}, {"envSustain", 0.0f}, {"envRelease", 0.5f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.902f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 3}, {"compAttack", 5}, {"compRelease", 50}, {"compMakeup", 2}, @@ -716,14 +716,14 @@ private: // ======== CINEMATIC ======== - add("Space Station", "Cinematic", { + add("Orbital Station", "Cinematic", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 5}, {"osc1Level", 0.4f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", -8}, {"osc2Level", 0.4f}, {"phaseOffset", 0.2f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.15f}, {"keyTrack", 0.3f}, {"fEnvAttack", 2.5f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 5.0f}, {"envAttack", 4.0f}, {"envDecay", 2.0f}, {"envSustain", 0.85f}, {"envRelease", 6.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.404f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 35}, {"compRelease", 400}, {"compMakeup", 3}, @@ -735,14 +735,14 @@ private: {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.7f} }); - add("Tornado Siren", "Cinematic", { + add("Storm Siren", "Cinematic", { {"osc1Wave", 1}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", 3}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 900}, {"filterRes", 0.7f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.0f}, {"fEnvAttack", 3.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 3.0f}, {"envAttack", 0.5f}, {"envDecay", 0.5f}, {"envSustain", 0.9f}, {"envRelease", 2.0f}, - {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.568}, + {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.723}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 15}, {"compRelease", 200}, {"compMakeup", 3}, @@ -754,14 +754,14 @@ private: {"reverbSize", 0.8f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.4f} }); - add("Black Hole", "Cinematic", { + add("Singularity", "Cinematic", { {"osc1Wave", 0}, {"osc1Oct", -3}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 3}, {"osc2Oct", -2}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.1f}, {"filterType", 0}, {"filterCutoff", 150}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.2f}, {"fEnvAttack", 4.0f}, {"fEnvDecay", 5.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 8.0f}, {"envAttack", 5.0f}, {"envDecay", 3.0f}, {"envSustain", 0.9f}, {"envRelease", 8.0f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.55f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.375f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -30}, {"compRatio", 2}, {"compAttack", 50}, {"compRelease", 600}, {"compMakeup", 3}, @@ -773,14 +773,14 @@ private: {"reverbSize", 0.98f}, {"reverbDamping", 0.02f}, {"reverbMix", 0.8f} }); - add("Molten Core", "Cinematic", { + add("Plasma Core", "Cinematic", { {"osc1Wave", 1}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", -5}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.7f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 200}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.2f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 1.5f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 2.0f}, {"envAttack", 0.5f}, {"envDecay", 0.5f}, {"envSustain", 0.8f}, {"envRelease", 1.5f}, - {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 0.326}, + {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 0.584}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 6}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 4}, @@ -792,14 +792,14 @@ private: {"reverbSize", 0.7f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.35f} }); - add("Thunder Roll", "Cinematic", { + add("Rumble Array", "Cinematic", { {"osc1Wave", 4}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.5f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 1.5f}, {"envAttack", 0.3f}, {"envDecay", 0.8f}, {"envSustain", 0.6f}, {"envRelease", 2.0f}, - {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.415}, + {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.746}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 4}, @@ -811,14 +811,14 @@ private: {"reverbSize", 0.9f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.5f} }); - add("Haunted Mansion", "Cinematic", { + add("Phantom Sector", "Cinematic", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -12}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 6}, {"osc2Fine", 15}, {"osc2Level", 0.4f}, {"phaseOffset", 0.7f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.3f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.0f}, {"envDecay", 1.5f}, {"envSustain", 0.6f}, {"envRelease", 4.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 350}, {"compMakeup", 2}, @@ -830,18 +830,18 @@ private: {"reverbSize", 0.9f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.6f} }); - add("Ancient Machine", "Cinematic", {{{"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", -15}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 18}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 500}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.8f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 1.5f}, {"envAttack", 0.5f}, {"envDecay", 0.8f}, {"envSustain", 0.7f}, {"envRelease", 2.0f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.621}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 10}, {"compRelease", 150}, {"compMakeup", 3}, {"autoPanRate", 0.15f}, {"autoPanDepth", 0.3f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.5f}, {"lfo1Depth", 0.45f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.2f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 500}, {"delayFeedback", 0.45f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.75f}, {"reverbDamping", 0.25f}, {"reverbMix", 0.4f}}}); + add("Antique Automaton", "Cinematic", {{{"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", -15}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 18}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 500}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.8f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 1.5f}, {"envAttack", 0.5f}, {"envDecay", 0.8f}, {"envSustain", 0.7f}, {"envRelease", 2.0f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 10}, {"compRelease", 150}, {"compMakeup", 3}, {"autoPanRate", 0.15f}, {"autoPanDepth", 0.3f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.5f}, {"lfo1Depth", 0.45f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.2f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 500}, {"delayFeedback", 0.45f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.75f}, {"reverbDamping", 0.25f}, {"reverbMix", 0.4f}}}); // ======== MORE BASS ======== - add("Concrete Jungle", "Bass", { + add("Urban Grid", "Bass", { {"osc1Wave", 1}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 5}, {"osc2Level", 0.6f}, {"phaseOffset", 0.45f}, {"filterType", 0}, {"filterCutoff", 180}, {"filterRes", 0.6f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.15f}, - {"pan", 0}, {"drive", 4.0f}, {"masterLevel", 0.261}, + {"pan", 0}, {"drive", 4.0f}, {"masterLevel", 0.457}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -10}, {"compRatio", 8}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 6}, @@ -853,18 +853,18 @@ private: {"reverbSize", 0.1f}, {"reverbDamping", 0.9f}, {"reverbMix", 0.03f} }); - add("Thunder Bass", "Bass", {{{"osc1Wave", 2}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 0}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 200}, {"filterRes", 0.7f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.6f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.351}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 5}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.2f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 100}, {"delayFeedback", 0.3f}, {"delayMix", 0.12f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.85f}, {"reverbMix", 0.05f}}}); + add("Storm Drain", "Bass", {{{"osc1Wave", 2}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 0}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 200}, {"filterRes", 0.7f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.6f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.539}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 5}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.2f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 100}, {"delayFeedback", 0.3f}, {"delayMix", 0.12f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.85f}, {"reverbMix", 0.05f}}}); - add("Dystopian Bass", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", -8}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 5}, {"osc2Fine", 12}, {"osc2Level", 0.7f}, {"phaseOffset", 0.25f}, {"filterType", 1}, {"filterCutoff", 300}, {"filterRes", 0.75f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.15f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.65f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 0.303}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 7}, {"compAttack", 2}, {"compRelease", 35}, {"compMakeup", 5}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.15f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 90}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.08f}}}); + add("Cyber Sub", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", -8}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 5}, {"osc2Fine", 12}, {"osc2Level", 0.7f}, {"phaseOffset", 0.25f}, {"filterType", 1}, {"filterCutoff", 300}, {"filterRes", 0.75f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.15f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.65f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 3.5f}, {"masterLevel", 0.562}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 7}, {"compAttack", 2}, {"compRelease", 35}, {"compMakeup", 5}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.15f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 90}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.08f}}}); - add("808 Subblast", "Bass", { + add("808 Pulse", "Bass", { {"osc1Wave", 0}, {"osc1Oct", -3}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 1.0f}, {"osc2Wave", 0}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 120}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.5f}, {"envSustain", 0.0f}, {"envRelease", 0.3f}, - {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.527}, + {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.779}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -10}, {"compRatio", 4}, {"compAttack", 2}, {"compRelease", 50}, {"compMakeup", 4}, @@ -878,24 +878,24 @@ private: // ======== MORE LEADS ======== - add("Neon Rider", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3500}, {"filterRes", 0.35f}, {"filterEnvAmt", 0.65f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.544}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.5f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Neon Vector", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3500}, {"filterRes", 0.35f}, {"filterEnvAmt", 0.65f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.663}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.5f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); - add("Champagne Supernova", "Lead", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 3}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", -5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.35f}, {"filterType", 0}, {"filterCutoff", 4000}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.4f}, {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.7f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 2}, {"compAttack", 5}, {"compRelease", 100}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.2f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.1f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 300}, {"delayFeedback", 0.25f}, {"delayMix", 0.15f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.12f}}}); + add("Solar Nova", "Lead", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 3}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", -5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.35f}, {"filterType", 0}, {"filterCutoff", 4000}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.4f}, {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.768f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 2}, {"compAttack", 5}, {"compRelease", 100}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.2f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.1f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 300}, {"delayFeedback", 0.25f}, {"delayMix", 0.15f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.12f}}}); - add("Quantum Lead", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 5}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.7f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.47}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 40}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 7.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.3f}, {"lfo2Depth", 0.2f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.25f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Quantum Beam", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 5}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.7f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.651}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 40}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 7.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.3f}, {"lfo2Depth", 0.2f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.25f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); - add("Electric Sheep", "Lead", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -7}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.7f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.35f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.7f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 2}, {"compAttack", 3}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.15f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.12f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); + add("Android Flock", "Lead", {{{"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -7}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.7f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.35f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.712f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 2}, {"compAttack", 3}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.15f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.12f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); // ======== MORE PADS ======== - add("Infinite Horizon", "Pad", { + add("Horizon Loop", "Pad", { {"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -3}, {"osc1Level", 0.5f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.4f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.15f}, {"keyTrack", 0.5f}, {"fEnvAttack", 3.0f}, {"fEnvDecay", 4.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 6.0f}, {"envAttack", 4.0f}, {"envDecay", 3.0f}, {"envSustain", 0.85f}, {"envRelease", 7.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.361f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -30}, {"compRatio", 1.5f}, {"compAttack", 50}, {"compRelease", 600}, {"compMakeup", 2}, @@ -907,14 +907,14 @@ private: {"reverbSize", 0.98f}, {"reverbDamping", 0.02f}, {"reverbMix", 0.75f} }); - add("Liquid Gold", "Pad", { + add("Gold Fluid", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 2}, {"osc1Level", 0.5f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 4}, {"osc2Fine", -3}, {"osc2Level", 0.4f}, {"phaseOffset", 0.55f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.0f}, {"envDecay", 1.5f}, {"envSustain", 0.8f}, {"envRelease", 4.0f}, - {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.735f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -22}, {"compRatio", 2}, {"compAttack", 25}, {"compRelease", 250}, {"compMakeup", 2}, @@ -926,14 +926,14 @@ private: {"reverbSize", 0.85f}, {"reverbDamping", 0.15f}, {"reverbMix", 0.5f} }); - add("Apocalypse Now", "Pad", { + add("Apocalypse Grid", "Pad", { {"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", -10}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 6}, {"osc2Fine", 14}, {"osc2Level", 0.5f}, {"phaseOffset", 0.2f}, {"filterType", 0}, {"filterCutoff", 200}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.3f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 5.0f}, {"envAttack", 3.0f}, {"envDecay", 2.0f}, {"envSustain", 0.7f}, {"envRelease", 6.0f}, - {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.467f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -20}, {"compRatio", 3}, {"compAttack", 20}, {"compRelease", 200}, {"compMakeup", 3}, @@ -947,24 +947,24 @@ private: // ======== MORE FX ======== - add("Pirate Radio", "FX", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 3}, {"osc2Fine", 31}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 500}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.5f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.479}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 5}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.2f}, {"lfo2Depth", 0.7f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.5f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); + add("Bootleg Signal", "FX", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 3}, {"osc2Fine", 31}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 2}, {"filterCutoff", 500}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.5f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.785}, {"pitchBendRange", 2}, {"distType", 1}, {"distAmount", 0}, {"compThreshold", -15}, {"compRatio", 5}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.2f}, {"lfo2Depth", 0.7f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.5f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); - add("Vapor Trail", "FX", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 5}, {"osc1Level", 0.5f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", -5}, {"osc2Level", 0.4f}, {"phaseOffset", 0.6f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.5f}, {"envDecay", 1.0f}, {"envSustain", 0.7f}, {"envRelease", 4.0f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 300}, {"compMakeup", 2}, {"autoPanRate", 0.25f}, {"autoPanDepth", 0.7f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.2f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 500}, {"delayFeedback", 0.6f}, {"delayMix", 0.4f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.85f}, {"reverbDamping", 0.15f}, {"reverbMix", 0.55f}}}); + add("Vapor Trace", "FX", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 5}, {"osc1Level", 0.5f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", -5}, {"osc2Level", 0.4f}, {"phaseOffset", 0.6f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.5f}, {"envDecay", 1.0f}, {"envSustain", 0.7f}, {"envRelease", 4.0f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 300}, {"compMakeup", 2}, {"autoPanRate", 0.25f}, {"autoPanDepth", 0.7f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.2f}, {"lfo1Depth", 0.2f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.15f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 500}, {"delayFeedback", 0.6f}, {"delayMix", 0.4f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.85f}, {"reverbDamping", 0.15f}, {"reverbMix", 0.55f}}}); - add("Sugar Rush", "FX", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.3f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 2}, {"autoPanRate", 3.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.5f}, {"lfo2Depth", 0.2f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0.35f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.25f}}}); + add("Candy Overdrive", "FX", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.3f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 2}, {"autoPanRate", 3.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.5f}, {"lfo2Depth", 0.2f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0.35f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.25f}}}); - add("Fleshlight", "FX", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 1}, {"osc2Fine", 8}, {"osc2Level", 0.6f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.6f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.413}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, {"autoPanRate", 4.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 8.0f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 80}, {"delayFeedback", 0.4f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); + add("Polymorph Unit", "FX", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 1}, {"osc2Fine", 8}, {"osc2Level", 0.6f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.6f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 3.0f}, {"masterLevel", 0.776}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 6}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, {"autoPanRate", 4.0f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.6f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 8.0f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 80}, {"delayFeedback", 0.4f}, {"delayMix", 0.2f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); // ======== PIANO ======== - add("Grand Piano", "Piano", { + add("Ivory Array", "Piano", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 3}, {"osc2Level", 0.2f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 10000}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.95f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.06f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.04f}, {"envAttack", 0.001f}, {"envDecay", 2.5f}, {"envSustain", 0.0f}, {"envRelease", 0.2f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.846f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 1.5f}, {"compAttack", 5}, {"compRelease", 30}, {"compMakeup", 1}, @@ -976,14 +976,14 @@ private: {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f} }); - add("Honky Tonk", "Piano", { + add("Wonky Tonky", "Piano", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -8}, {"osc1Level", 0.7f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.7f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 12000}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.95f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.05f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.04f}, {"envAttack", 0.001f}, {"envDecay", 0.07f}, {"envSustain", 0.0f}, {"envRelease", 0.05f}, - {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.597}, + {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.812}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 2}, {"compAttack", 3}, {"compRelease", 25}, {"compMakeup", 2}, @@ -995,14 +995,14 @@ private: {"reverbSize", 0.12f}, {"reverbDamping", 0.9f}, {"reverbMix", 0.04f} }); - add("EP Tine", "Piano", { + add("Tina Circuit", "Piano", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", -5}, {"osc2Level", 0.25f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 8000}, {"filterRes", 0.08f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.0f}, {"envRelease", 0.08f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.917f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -18}, {"compRatio", 1.5f}, {"compAttack", 5}, {"compRelease", 25}, {"compMakeup", 1}, @@ -1014,14 +1014,14 @@ private: {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.06f} }); - add("Dark Piano", "Piano", { + add("Shadow Keys", "Piano", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -3}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 5}, {"osc2Level", 0.2f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.005f}, {"envDecay", 0.4f}, {"envSustain", 0.0f}, {"envRelease", 0.35f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.956f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 2}, {"compAttack", 3}, {"compRelease", 100}, {"compMakeup", 2}, @@ -1033,14 +1033,14 @@ private: {"reverbSize", 0.35f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.18f} }); - add("Piano Layer", "Piano", { + add("Key Stack", "Piano", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.2f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 7000}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.45f}, {"keyTrack", 0.95f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.0f}, {"envRelease", 0.25f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.877f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 3}, {"compAttack", 1}, {"compRelease", 60}, {"compMakeup", 3}, @@ -1054,14 +1054,14 @@ private: // ======== MORE PADS ======== - add("Ambient Swell", "Pad", { + add("Drone Swell", "Pad", { {"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -5}, {"osc1Level", 0.5f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 400}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.4f}, {"fEnvAttack", 3.0f}, {"fEnvDecay", 4.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 6.0f}, {"envAttack", 4.0f}, {"envDecay", 3.0f}, {"envSustain", 0.85f}, {"envRelease", 7.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.534f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -30}, {"compRatio", 1.5f}, {"compAttack", 50}, {"compRelease", 600}, {"compMakeup", 2}, @@ -1073,14 +1073,14 @@ private: {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.75f} }); - add("Analog Strings", "Pad", { + add("String Array", "Pad", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -8}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.6f}, {"phaseOffset", 0.25f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.15f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.5f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 2.0f}, {"envAttack", 1.5f}, {"envDecay", 1.0f}, {"envSustain", 0.8f}, {"envRelease", 3.0f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.639f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 2}, {"compAttack", 20}, {"compRelease", 200}, {"compMakeup", 2}, @@ -1092,14 +1092,14 @@ private: {"reverbSize", 0.7f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.35f} }); - add("Digital Cloud", "Pad", { + add("Cloud Compute", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 3}, {"osc1Level", 0.4f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", -3}, {"osc2Level", 0.4f}, {"phaseOffset", 0.7f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.08f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.6f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 4.0f}, {"envAttack", 3.0f}, {"envDecay", 2.0f}, {"envSustain", 0.7f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.55f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.485f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -28}, {"compRatio", 1.5f}, {"compAttack", 40}, {"compRelease", 500}, {"compMakeup", 3}, @@ -1113,14 +1113,14 @@ private: // ======== MORE KEYS ======== - add("Wurlitzer", "Keys", { + add("Wurlitz0r", "Keys", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.35f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 750}, {"filterRes", 0.12f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.4f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.6f}, {"envAttack", 0.001f}, {"envDecay", 0.5f}, {"envSustain", 0.3f}, {"envRelease", 0.8f}, - {"pan", 0}, {"drive", 1.4f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.4f}, {"masterLevel", 0.887f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 2}, @@ -1132,14 +1132,14 @@ private: {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.18f} }); - add("Harpsichord", "Keys", { + add("Harpsi Chordz", "Keys", { {"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.05f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.0f}, {"envRelease", 0.15f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -15}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 2}, @@ -1153,14 +1153,14 @@ private: // ======== MORE BASS 2 ======== - add("Slap Bass", "Bass", { + add("Slap Circuit", "Bass", { {"osc1Wave", 2}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.5f}, {"phaseOffset", 0.45f}, {"filterType", 0}, {"filterCutoff", 450}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.0f}, {"envRelease", 0.08f}, - {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.464}, + {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.923}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, @@ -1172,14 +1172,14 @@ private: {"reverbSize", 0.12f}, {"reverbDamping", 0.85f}, {"reverbMix", 0.04f} }); - add("Synthwave Bass", "Bass", { + add("Retrowave Cell", "Bass", { {"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 12}, {"osc2Fine", -5}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.65f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.15f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.6f}, {"envRelease", 0.15f}, - {"pan", 0}, {"drive", 2.4f}, {"masterLevel", 0.409}, + {"pan", 0}, {"drive", 2.4f}, {"masterLevel", 0.632}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, @@ -1191,16 +1191,16 @@ private: {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f} }); - add("Acid Squelch", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 250}, {"filterRes", 0.95f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.25f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.3f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 2.8f}, {"masterLevel", 0.409}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 6}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 5}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 90}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f}}}); + add("Squelch Circuit", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.9f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 250}, {"filterRes", 0.95f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.25f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.3f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 2.8f}, {"masterLevel", 0.599}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 6}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 5}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 90}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f}}}); - add("Resonant Sub", "Bass", { + add("Reso Core", "Bass", { {"osc1Wave", 0}, {"osc1Oct", -3}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 1.0f}, {"osc2Wave", 0}, {"osc2Oct", -2}, {"osc2Semi", 0}, {"osc2Fine", 12}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 90}, {"filterRes", 0.85f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.4f}, {"envSustain", 0.0f}, {"envRelease", 0.25f}, - {"pan", 0}, {"drive", 1.6f}, {"masterLevel", 0.495}, + {"pan", 0}, {"drive", 1.6f}, {"masterLevel", 0.706}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -8}, {"compRatio", 4}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, @@ -1214,24 +1214,24 @@ private: // ======== MORE LEADS 2 ======== - add("Brass Stab", "Lead", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.8f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.559}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 50}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Stab Core", "Lead", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.1f}, {"envSustain", 0.8f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.635}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 50}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); - add("Pluck Lead", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 4000}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.06f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.0f}, {"envRelease", 0.06f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.08f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 140}, {"delayFeedback", 0.25f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.75f}, {"reverbMix", 0.06f}}}); + add("Rubber Transient", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 4000}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.9f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.06f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.0f}, {"envRelease", 0.06f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.08f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 140}, {"delayFeedback", 0.25f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.15f}, {"reverbDamping", 0.75f}, {"reverbMix", 0.06f}}}); - add("Vocal Lead", "Lead", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -5}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 5}, {"osc2Level", 0.4f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 2800}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.02f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.05f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 2}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.08f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.12f}}}); + add("Voice Beam", "Lead", {{{"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -5}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 5}, {"osc2Level", 0.4f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 2800}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.02f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.05f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.3f}, {"masterLevel", 0.79f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 2}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.08f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.12f}}}); - add("Supersaw Lead", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3500}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.85f}, {"envRelease", 0.25f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.572}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.12f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.6f}, {"lfo2Depth", 0.1f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 140}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Supersaw Array", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.6f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3500}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.85f}, {"envRelease", 0.25f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.681}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.12f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.6f}, {"lfo2Depth", 0.1f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 140}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); // ======== MORE PADS 2 ======== - add("Heaven Pad", "Pad", { + add("Sky Module", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 3}, {"osc1Level", 0.5f}, {"osc2Wave", 3}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", -5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.4f}, {"filterType", 0}, {"filterCutoff", 450}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.15f}, {"keyTrack", 0.6f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 5.0f}, {"envAttack", 3.0f}, {"envDecay", 2.5f}, {"envSustain", 0.85f}, {"envRelease", 6.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.368f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -30}, {"compRatio", 1.5f}, {"compAttack", 50}, {"compRelease", 600}, {"compMakeup", 2}, @@ -1243,14 +1243,14 @@ private: {"reverbSize", 0.98f}, {"reverbDamping", 0.02f}, {"reverbMix", 0.8f} }); - add("Vintage Pad", "Pad", { + add("Vintage Haze", "Pad", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -4}, {"osc1Level", 0.5f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 4}, {"osc2Level", 0.5f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 320}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.4f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.0f}, {"envDecay", 1.5f}, {"envSustain", 0.75f}, {"envRelease", 4.0f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.606f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -24}, {"compRatio", 2}, {"compAttack", 25}, {"compRelease", 250}, {"compMakeup", 2}, @@ -1262,14 +1262,14 @@ private: {"reverbSize", 0.8f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.45f} }); - add("Dream Catcher", "Pad", { + add("Dream Matrix", "Pad", { {"osc1Wave", 3}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.45f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.45f}, {"phaseOffset", 0.6f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.12f}, {"filterEnvAmt", 0.25f}, {"keyTrack", 0.6f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.5f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 4.0f}, {"envAttack", 2.5f}, {"envDecay", 2.0f}, {"envSustain", 0.8f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.65f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.424f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -26}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 300}, {"compMakeup", 2}, @@ -1281,14 +1281,14 @@ private: {"reverbSize", 0.9f}, {"reverbDamping", 0.1f}, {"reverbMix", 0.6f} }); - add("Astral Drift", "Pad", { + add("Astral Vector", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -7}, {"osc1Level", 0.5f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 7}, {"osc2Fine", 11}, {"osc2Level", 0.3f}, {"phaseOffset", 0.7f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.18f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 2.0f}, {"fEnvDecay", 3.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 5.0f}, {"envAttack", 3.0f}, {"envDecay", 2.5f}, {"envSustain", 0.8f}, {"envRelease", 6.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -28}, {"compRatio", 1.5f}, {"compAttack", 40}, {"compRelease", 500}, {"compMakeup", 3}, @@ -1302,14 +1302,14 @@ private: // ======== MORE KEYS 2 ======== - add("Celesta", "Keys", { + add("Celestial Cell", "Keys", { {"osc1Wave", 0}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 3}, {"osc2Oct", 2}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1500}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.5f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.001f}, {"envDecay", 0.5f}, {"envSustain", 0.0f}, {"envRelease", 0.6f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.75f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.947f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 2}, {"compAttack", 5}, {"compRelease", 60}, {"compMakeup", 2}, @@ -1321,14 +1321,14 @@ private: {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f} }); - add("Music Box", "Keys", { + add("Music Cell", "Keys", { {"osc1Wave", 0}, {"osc1Oct", 2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 2}, {"osc2Oct", 2}, {"osc2Semi", 12}, {"osc2Fine", -3}, {"osc2Level", 0.25f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1800}, {"filterRes", 0.08f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.4f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.0f}, {"envRelease", 0.5f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.75f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 2}, {"compAttack", 3}, {"compRelease", 50}, {"compMakeup", 2}, @@ -1340,26 +1340,26 @@ private: {"reverbSize", 0.45f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.18f} }); - add("Vibraphone", "Keys", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.6f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.8f}, {"envAttack", 0.001f}, {"envDecay", 0.7f}, {"envSustain", 0.2f}, {"envRelease", 1.0f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 2}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.5f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 350}, {"delayFeedback", 0.1f}, {"delayMix", 0.05f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.55f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.25f}}}); + add("Vibe Array", "Keys", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.6f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.8f}, {"envAttack", 0.001f}, {"envDecay", 0.7f}, {"envSustain", 0.2f}, {"envRelease", 1.0f}, {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.979f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 2}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.5f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 350}, {"delayFeedback", 0.1f}, {"delayMix", 0.05f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.55f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.25f}}}); - add("Accordion", "Keys", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 900}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.8f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.02f}, {"envDecay", 0.1f}, {"envSustain", 0.9f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 8}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.05f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0}, {"delayMix", 0}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); + add("Bellows Unit", "Keys", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 900}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.8f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.02f}, {"envDecay", 0.1f}, {"envSustain", 0.9f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.792f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 3}, {"compAttack", 8}, {"compRelease", 80}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.5f}, {"lfo1Depth", 0.05f}, {"lfo1Shape", 3}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0}, {"delayMix", 0}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); // ======== BRASS ======== - add("Section Brass", "Brass", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.02f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.05f}, {"envDecay", 0.2f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.08f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.05f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.35f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.15f}}}); + add("Sector 3 Brass", "Brass", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.02f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.05f}, {"envDecay", 0.2f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.636f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.08f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.05f}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.35f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.15f}}}); - add("Stab Brass", "Brass", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2200}, {"filterRes", 0.45f}, {"filterEnvAmt", 0.85f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.533}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 40}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); + add("Horn Stab", "Brass", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2200}, {"filterRes", 0.45f}, {"filterEnvAmt", 0.85f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.624}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 40}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); // ======== STRINGS ======== - add("Solo Cello", "Strings", { + add("String Cell", "Strings", { {"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", -8}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", -1}, {"osc2Semi", 12}, {"osc2Fine", 5}, {"osc2Level", 0.3f}, {"phaseOffset", 0.4f}, {"filterType", 0}, {"filterCutoff", 600}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.2f}, {"fEnvDecay", 0.5f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.5f}, {"envAttack", 0.3f}, {"envDecay", 0.4f}, {"envSustain", 0.8f}, {"envRelease", 0.8f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.75f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.894f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 2}, {"compAttack", 15}, {"compRelease", 150}, {"compMakeup", 2}, @@ -1371,14 +1371,14 @@ private: {"reverbSize", 0.6f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.3f} }); - add("Orchestra", "Strings", { + add("Orchestra Matrix", "Strings", { {"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -5}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.4f}, {"phaseOffset", 0.3f}, {"filterType", 0}, {"filterCutoff", 700}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.15f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.8f}, {"fEnvDecay", 1.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 1.5f}, {"envAttack", 1.0f}, {"envDecay", 0.8f}, {"envSustain", 0.85f}, {"envRelease", 2.0f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.7f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.702f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -22}, {"compRatio", 2}, {"compAttack", 20}, {"compRelease", 200}, {"compMakeup", 2}, @@ -1392,14 +1392,14 @@ private: // ======== WIND ======== - add("Flute", "Wind", { + add("Flute Engine", "Wind", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.2f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1500}, {"filterRes", 0.08f}, {"filterEnvAmt", 0.1f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.05f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 0.4f}, {"envAttack", 0.08f}, {"envDecay", 0.3f}, {"envSustain", 0.8f}, {"envRelease", 0.5f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.75f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.756f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -20}, {"compRatio", 2}, {"compAttack", 8}, {"compRelease", 100}, {"compMakeup", 2}, @@ -1411,14 +1411,14 @@ private: {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f} }); - add("Saxophone", "Wind", { + add("Sax Engine", "Wind", { {"osc1Wave", 3}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", -7}, {"osc1Level", 0.6f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 7}, {"osc2Level", 0.4f}, {"phaseOffset", 0.35f}, {"filterType", 0}, {"filterCutoff", 1000}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.03f}, {"fEnvDecay", 0.3f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 0.4f}, {"envAttack", 0.05f}, {"envDecay", 0.3f}, {"envSustain", 0.75f}, {"envRelease", 0.4f}, - {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.75f}, + {"pan", 0}, {"drive", 1.5f}, {"masterLevel", 0.801f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 5}, {"compRelease", 80}, {"compMakeup", 2}, @@ -1432,20 +1432,20 @@ private: // ======== ARP ======== - add("Bright Arp", "Arp", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.04f}, {"envAttack", 0.001f}, {"envDecay", 0.08f}, {"envSustain", 0.0f}, {"envRelease", 0.04f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.574}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 25}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 130}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); + add("Arp Cascade", "Arp", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.08f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.04f}, {"envAttack", 0.001f}, {"envDecay", 0.08f}, {"envSustain", 0.0f}, {"envRelease", 0.04f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 25}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 130}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); - add("Mellow Arp", "Arp", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.0f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 2.5f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.3f}, {"delayMix", 0.18f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.45f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); + add("Arp Haze", "Arp", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.0f}, {"envRelease", 0.1f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 40}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 2.5f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.3f}, {"delayMix", 0.18f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.45f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); // ======== PLUCK ======== - add("Koto Pluck", "Pluck", { + add("Koto Cell", "Pluck", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.2f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.08f}, {"envAttack", 0.001f}, {"envDecay", 0.15f}, {"envSustain", 0.0f}, {"envRelease", 0.1f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 2}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 2}, @@ -1457,14 +1457,14 @@ private: {"reverbSize", 0.4f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.18f} }); - add("Pizzicato", "Pluck", { + add("Staccato Cell", "Pluck", { {"osc1Wave", 1}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 1}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2200}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.06f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.0f}, {"envRelease", 0.08f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.78f}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 2}, @@ -1478,22 +1478,22 @@ private: // ======== MORE FX 2 ======== - add("Bitcrush", "FX", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.38}, {"pitchBendRange", 2}, {"distType", 2}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 50}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.2f}, {"lfo2Depth", 0.5f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); + add("Byte Crusher", "FX", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.709}, {"pitchBendRange", 2}, {"distType", 2}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 50}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 6.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.2f}, {"lfo2Depth", 0.5f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 150}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.2f}}}); - add("Comb Filter", "FX", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 1}, {"filterCutoff", 600}, {"filterRes", 0.9f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.6f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.7f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 4}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0.3f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 300}, {"delayFeedback", 0.5f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.25f}}}); + add("Comb Array", "FX", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 4}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 1}, {"filterCutoff", 600}, {"filterRes", 0.9f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.0f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.4f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.6f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.933f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 4}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0.3f}, {"autoPanDepth", 0.5f}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.4f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.1f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 300}, {"delayFeedback", 0.5f}, {"delayMix", 0.3f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.5f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.25f}}}); - add("Granular Cloud", "FX", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.4f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.0f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 3.0f}, {"envAttack", 1.5f}, {"envDecay", 1.5f}, {"envSustain", 0.7f}, {"envRelease", 3.0f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.6f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -28}, {"compRatio", 1.5f}, {"compAttack", 40}, {"compRelease", 400}, {"compMakeup", 3}, {"autoPanRate", 0.2f}, {"autoPanDepth", 0.7f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.14f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 4}, {"lfo2Rate", 0.05f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 700}, {"delayFeedback", 0.7f}, {"delayMix", 0.5f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.7f}}}); + add("Grain Array", "FX", {{{"osc1Wave", 4}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.4f}, {"osc2Wave", 4}, {"osc2Oct", 0}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.5f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.0f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.5f}, {"fEnvRelease", 3.0f}, {"envAttack", 1.5f}, {"envDecay", 1.5f}, {"envSustain", 0.7f}, {"envRelease", 3.0f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -28}, {"compRatio", 1.5f}, {"compAttack", 40}, {"compRelease", 400}, {"compMakeup", 3}, {"autoPanRate", 0.2f}, {"autoPanDepth", 0.7f}, {"autoPanPhase", 0}, {"lfo1Rate", 0.14f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 4}, {"lfo2Rate", 0.05f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 1}, {"lfo2Dest", 0}, {"delayTime", 700}, {"delayFeedback", 0.7f}, {"delayMix", 0.5f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 1}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.95f}, {"reverbDamping", 0.05f}, {"reverbMix", 0.7f}}}); // ======== ENCORE 9 ======== - add("Kalimba", "Pluck", { + add("Kalimbo", "Pluck", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 0}, {"osc2Oct", 2}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3000}, {"filterRes", 0.05f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.14f}, {"envSustain", 0.0f}, {"envRelease", 0.12f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.8f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 2}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 2}, @@ -1505,14 +1505,14 @@ private: {"reverbSize", 0.4f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.18f} }); - add("Harp", "Pluck", { + add("Harp Engine", "Pluck", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 3}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3500}, {"filterRes", 0.08f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.0f}, {"envRelease", 0.15f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.78f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -18}, {"compRatio", 2}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 2}, @@ -1524,16 +1524,16 @@ private: {"reverbSize", 0.5f}, {"reverbDamping", 0.3f}, {"reverbMix", 0.22f} }); - add("Acid Lead", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.95f}, {"filterEnvAmt", 0.95f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.18f}, {"envSustain", 0.6f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.6f}, {"masterLevel", 0.476}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 130}, {"delayFeedback", 0.25f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Acid Emitter", "Lead", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 800}, {"filterRes", 0.95f}, {"filterEnvAmt", 0.95f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.18f}, {"envSustain", 0.6f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.6f}, {"masterLevel", 0.585}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.3f}, {"lfo1Shape", 2}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 130}, {"delayFeedback", 0.25f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); - add("Deep House Bass", "Bass", { + add("Deep Cell", "Bass", { {"osc1Wave", 1}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.85f}, {"osc2Wave", 0}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 220}, {"filterRes", 0.55f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.5f}, {"envRelease", 0.15f}, - {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.522}, + {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.62}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, @@ -1545,16 +1545,16 @@ private: {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f} }); - add("Neuro Bass", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", -10}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 5}, {"osc2Fine", 14}, {"osc2Level", 0.6f}, {"phaseOffset", 0.3f}, {"filterType", 1}, {"filterCutoff", 300}, {"filterRes", 0.9f}, {"filterEnvAmt", 0.95f}, {"keyTrack", 0.2f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.5f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 4.0f}, {"masterLevel", 0.255}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -10}, {"compRatio", 8}, {"compAttack", 1}, {"compRelease", 25}, {"compMakeup", 6}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.2f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 80}, {"delayFeedback", 0.3f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.1f}, {"reverbDamping", 0.9f}, {"reverbMix", 0.03f}}}); + add("Neural Drain", "Bass", {{{"osc1Wave", 1}, {"osc1Oct", -2}, {"osc1Semi", 0}, {"osc1Fine", -10}, {"osc1Level", 0.9f}, {"osc2Wave", 2}, {"osc2Oct", -1}, {"osc2Semi", 5}, {"osc2Fine", 14}, {"osc2Level", 0.6f}, {"phaseOffset", 0.3f}, {"filterType", 1}, {"filterCutoff", 300}, {"filterRes", 0.9f}, {"filterEnvAmt", 0.95f}, {"keyTrack", 0.2f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.12f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.1f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.5f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 4.0f}, {"masterLevel", 0.449}, {"pitchBendRange", 2}, {"distType", 3}, {"distAmount", 0}, {"compThreshold", -10}, {"compRatio", 8}, {"compAttack", 1}, {"compRelease", 25}, {"compMakeup", 6}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 5.0f}, {"lfo1Depth", 0.5f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0.2f}, {"lfo2Depth", 0.3f}, {"lfo2Shape", 2}, {"lfo2Dest", 0}, {"delayTime", 80}, {"delayFeedback", 0.3f}, {"delayMix", 0.12f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.1f}, {"reverbDamping", 0.9f}, {"reverbMix", 0.03f}}}); - add("Crystal Pad", "Pad", { + add("Prism Wash", "Pad", { {"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.45f}, {"osc2Wave", 0}, {"osc2Oct", 2}, {"osc2Semi", 7}, {"osc2Fine", 0}, {"osc2Level", 0.4f}, {"phaseOffset", 0.6f}, {"filterType", 0}, {"filterCutoff", 700}, {"filterRes", 0.08f}, {"filterEnvAmt", 0.2f}, {"keyTrack", 0.7f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.5f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 4.0f}, {"envAttack", 2.5f}, {"envDecay", 2.0f}, {"envSustain", 0.8f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.0f}, {"masterLevel", 0.437f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -28}, {"compRatio", 1.5f}, {"compAttack", 40}, {"compRelease", 500}, {"compMakeup", 2}, @@ -1566,28 +1566,28 @@ private: {"reverbSize", 0.92f}, {"reverbDamping", 0.08f}, {"reverbMix", 0.7f} }); - add("Trumpet", "Brass", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.75f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2000}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.02f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.04f}, {"envDecay", 0.25f}, {"envSustain", 0.8f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.744}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.18f}}}); + add("Horn Cell", "Brass", {{{"osc1Wave", 2}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.75f}, {"osc2Wave", 1}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2000}, {"filterRes", 0.25f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.02f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.04f}, {"envDecay", 0.25f}, {"envSustain", 0.8f}, {"envRelease", 0.3f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.626}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 3}, {"compRelease", 60}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 4.0f}, {"lfo1Depth", 0.1f}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 180}, {"delayFeedback", 0.15f}, {"delayMix", 0.08f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 0}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.5f}, {"reverbMix", 0.18f}}}); - add("Steel Drum", "Keys", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 2}, {"osc2Semi", 0}, {"osc2Fine", 4}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.0f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.78f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0}, {"lfo1Depth", 0}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.45f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); + add("Steel Cell", "Keys", {{{"osc1Wave", 0}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 2}, {"osc2Semi", 0}, {"osc2Fine", 4}, {"osc2Level", 0.4f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2500}, {"filterRes", 0.1f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.9f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.0f}, {"envRelease", 0.15f}, {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 2}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0}, {"lfo1Depth", 0}, {"lfo1Shape", 0}, {"lfo1Dest", 0}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 250}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 0}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.45f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); - add("Echo Pluck", "Arp", {{{"osc1Wave", 1}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2800}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.85f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.06f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.0f}, {"envRelease", 0.08f}, {"pan", 0}, {"drive", 1.6f}, {"masterLevel", 0.75f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.35f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 290}, {"delayFeedback", 0.55f}, {"delayMix", 0.35f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); + add("Echo Transient", "Arp", {{{"osc1Wave", 1}, {"osc1Oct", 1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 0}, {"osc2Oct", 1}, {"osc2Semi", 12}, {"osc2Fine", 0}, {"osc2Level", 0.3f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 2800}, {"filterRes", 0.2f}, {"filterEnvAmt", 0.85f}, {"keyTrack", 0.8f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.1f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.06f}, {"envAttack", 0.001f}, {"envDecay", 0.12f}, {"envSustain", 0.0f}, {"envRelease", 0.08f}, {"pan", 0}, {"drive", 1.6f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -16}, {"compRatio", 3}, {"compAttack", 1}, {"compRelease", 30}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 3.0f}, {"lfo1Depth", 0.35f}, {"lfo1Shape", 2}, {"lfo1Dest", 4}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 290}, {"delayFeedback", 0.55f}, {"delayMix", 0.35f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.4f}, {"reverbDamping", 0.4f}, {"reverbMix", 0.2f}}}); // ======== TECHNO ======== - add("Techno Stab", "Techno", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.18f}, {"envSustain", 0.0f}, {"envRelease", 0.12f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.622}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 40}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 1.5f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 3}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); + add("Technoid Core", "Techno", {{{"osc1Wave", 1}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 2}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", 5}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 1200}, {"filterRes", 0.4f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.6f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.18f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.18f}, {"envSustain", 0.0f}, {"envRelease", 0.12f}, {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 4}, {"compAttack", 1}, {"compRelease", 40}, {"compMakeup", 3}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 1.5f}, {"lfo1Depth", 0.15f}, {"lfo1Shape", 0}, {"lfo1Dest", 3}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 200}, {"delayFeedback", 0.2f}, {"delayMix", 0.1f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.3f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f}}}); - add("Acid Pulse", "Techno", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.5f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.464}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.8f}, {"lfo1Depth", 0.18f}, {"lfo1Shape", 2}, {"lfo1Dest", 3}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); + add("Pulse Vector", "Techno", {{{"osc1Wave", 1}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.8f}, {"osc2Wave", 1}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 8}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 300}, {"filterRes", 0.8f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.3f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.1f}, {"fEnvRelease", 0.15f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.5f}, {"envRelease", 0.2f}, {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.663}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, {"autoPanRate", 0}, {"autoPanDepth", 0}, {"autoPanPhase", 0}, {"lfo1Rate", 0.8f}, {"lfo1Depth", 0.18f}, {"lfo1Shape", 2}, {"lfo1Dest", 3}, {"lfo2Rate", 0}, {"lfo2Depth", 0}, {"lfo2Shape", 0}, {"lfo2Dest", 0}, {"delayTime", 120}, {"delayFeedback", 0.3f}, {"delayMix", 0.15f}, {"lfo1Sync", 1}, {"lfo1Beat", 4}, {"lfo2Sync", 0}, {"lfo2Beat", 4}, {"delaySync", 1}, {"delayBeat", 4}, {"reverbSize", 0.2f}, {"reverbDamping", 0.7f}, {"reverbMix", 0.08f}}}); // ======== SUPERSAW ======== - add("JP8K Supersaw Bass", "Bass", { + add("JP8K Saw Array", "Bass", { {"osc1Wave", 16}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 0}, {"osc2Oct", -1}, {"osc2Semi", 0}, {"osc2Fine", 0}, {"osc2Level", 0.8f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 350}, {"filterRes", 0.55f}, {"filterEnvAmt", 0.5f}, {"keyTrack", 0.4f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.25f}, {"fEnvSustain", 0.2f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.3f}, {"envSustain", 0.7f}, {"envRelease", 0.2f}, - {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.5f}, + {"pan", 0}, {"drive", 1.8f}, {"masterLevel", 0.712f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -16}, {"compRatio", 4}, {"compAttack", 5}, {"compRelease", 60}, {"compMakeup", 3}, @@ -1599,14 +1599,14 @@ private: {"reverbSize", 0.15f}, {"reverbDamping", 0.8f}, {"reverbMix", 0.05f} }); - add("JP8K Feedback Bass", "Bass", { + add("JP8K Feedback", "Bass", { {"osc1Wave", 16}, {"osc1Oct", -1}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.7f}, {"osc2Wave", 16}, {"osc2Oct", -1}, {"osc2Semi", 7}, {"osc2Fine", 10}, {"osc2Level", 0.6f}, {"phaseOffset", 0.35f}, {"filterType", 0}, {"filterCutoff", 500}, {"filterRes", 0.7f}, {"filterEnvAmt", 0.8f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.2f}, {"fEnvSustain", 0.15f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.001f}, {"envDecay", 0.25f}, {"envSustain", 0.75f}, {"envRelease", 0.2f}, - {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.45}, + {"pan", 0}, {"drive", 2.2f}, {"masterLevel", 0.791}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -14}, {"compRatio", 5}, {"compAttack", 3}, {"compRelease", 50}, {"compMakeup", 4}, @@ -1618,14 +1618,14 @@ private: {"reverbSize", 0.1f}, {"reverbDamping", 0.85f}, {"reverbMix", 0.03f} }); - add("JP8K Trance Lead", "Lead", { + add("JP8K Trance", "Lead", { {"osc1Wave", 16}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.6f}, {"osc2Wave", 16}, {"osc2Oct", 0}, {"osc2Semi", 12}, {"osc2Fine", -6}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 3200}, {"filterRes", 0.35f}, {"filterEnvAmt", 0.7f}, {"keyTrack", 0.7f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.15f}, {"fEnvSustain", 0.0f}, {"fEnvRelease", 0.12f}, {"envAttack", 0.001f}, {"envDecay", 0.2f}, {"envSustain", 0.8f}, {"envRelease", 0.25f}, - {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.55}, + {"pan", 0}, {"drive", 2.0f}, {"masterLevel", 0.865}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -14}, {"compRatio", 3}, {"compAttack", 2}, {"compRelease", 60}, {"compMakeup", 3}, @@ -1644,7 +1644,7 @@ private: {"filterType", 2}, {"filterCutoff", 1000}, {"filterRes", 0.75f}, {"filterEnvAmt", 0.6f}, {"keyTrack", 0.5f}, {"fEnvAttack", 0.001f}, {"fEnvDecay", 0.25f}, {"fEnvSustain", 0.3f}, {"fEnvRelease", 0.2f}, {"envAttack", 0.005f}, {"envDecay", 0.25f}, {"envSustain", 0.8f}, {"envRelease", 0.2f}, - {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.42}, + {"pan", 0}, {"drive", 2.5f}, {"masterLevel", 0.686}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"compThreshold", -12}, {"compRatio", 5}, {"compAttack", 2}, {"compRelease", 40}, {"compMakeup", 4}, @@ -1656,14 +1656,14 @@ private: {"reverbSize", 0.25f}, {"reverbDamping", 0.6f}, {"reverbMix", 0.1f} }); - add("JP8K Supersaw Pad", "Pad", { + add("JP8K Saw Wash", "Pad", { {"osc1Wave", 16}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 0}, {"osc1Level", 0.5f}, {"osc2Wave", 16}, {"osc2Oct", 0}, {"osc2Semi", 7}, {"osc2Fine", -6}, {"osc2Level", 0.5f}, {"phaseOffset", 0.5f}, {"filterType", 0}, {"filterCutoff", 900}, {"filterRes", 0.3f}, {"filterEnvAmt", 0.4f}, {"keyTrack", 0.6f}, {"fEnvAttack", 1.5f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.6f}, {"fEnvRelease", 3.0f}, {"envAttack", 1.5f}, {"envDecay", 2.0f}, {"envSustain", 0.8f}, {"envRelease", 4.0f}, - {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 0.65}, + {"pan", 0}, {"drive", 1.2f}, {"masterLevel", 1.0}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -22}, {"compRatio", 2}, {"compAttack", 25}, {"compRelease", 250}, {"compMakeup", 2}, @@ -1675,14 +1675,14 @@ private: {"reverbSize", 0.85f}, {"reverbDamping", 0.2f}, {"reverbMix", 0.5f} }); - add("JP8K Dream Pad", "Pad", { + add("JP8K Dream", "Pad", { {"osc1Wave", 16}, {"osc1Oct", 0}, {"osc1Semi", 0}, {"osc1Fine", 5}, {"osc1Level", 0.45f}, {"osc2Wave", 16}, {"osc2Oct", 1}, {"osc2Semi", 0}, {"osc2Fine", -5}, {"osc2Level", 0.4f}, {"phaseOffset", 0.6f}, {"filterType", 0}, {"filterCutoff", 1800}, {"filterRes", 0.15f}, {"filterEnvAmt", 0.3f}, {"keyTrack", 0.7f}, {"fEnvAttack", 1.0f}, {"fEnvDecay", 2.0f}, {"fEnvSustain", 0.7f}, {"fEnvRelease", 3.0f}, {"envAttack", 2.0f}, {"envDecay", 1.5f}, {"envSustain", 0.85f}, {"envRelease", 5.0f}, - {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 0.6f}, + {"pan", 0}, {"drive", 1.1f}, {"masterLevel", 1.0f}, {"pitchBendRange", 2}, {"distType", 0}, {"distAmount", 0}, {"distSymmetry", 0}, {"distTone", 1.0f}, {"compThreshold", -25}, {"compRatio", 2}, {"compAttack", 30}, {"compRelease", 300}, {"compMakeup", 3}, diff --git a/Tools/LevelNormalizer.cpp b/Tools/LevelNormalizer.cpp new file mode 100644 index 0000000..e13792a --- /dev/null +++ b/Tools/LevelNormalizer.cpp @@ -0,0 +1,330 @@ +// LevelNormalizer — offline preset loudness calibration tool. +// +// Renders every factory preset through the real DSP chain (voice + FX) at a +// fixed master gain of 1.0, measures the resulting peak, and computes the +// "masterLevel" value that brings the peak to the target. Used to keep all +// factory presets at a consistent loudness. +// +// ./level_normalizer dry run (prints a table, changes nothing) +// ./level_normalizer --apply rewrites masterLevel in PresetManager.h +// +// Note: matches presets to masterLevel entries by insertion order — every +// preset must contain exactly one "masterLevel" parameter. + +#include +#include +#include "../Source/PresetManager.h" +#include "../Source/DSP/Voice.h" +#include "../Source/DSP/Distortion.h" +#include "../Source/DSP/Compressor.h" +#include "../Source/DSP/Limiter.h" +#include "../Source/DSP/Delay.h" +#include "../Source/DSP/Reverb.h" + +#include +#include +#include +#include +#include +#include + +namespace { + +constexpr double sampleRate = 44100.0; +constexpr int blockSize = 512; +constexpr double holdSeconds = 3.0; // typical held-note reference length +constexpr double tailSeconds = 5.0; +constexpr float targetPeak = 0.8f; +constexpr float targetRms = 0.15f; + +float param(const Preset& p, const char* id, float def) { + auto it = p.params.find(juce::String(id)); + return it != p.params.end() ? it->second : def; +} + +float paramInt(const Preset& p, const char* id, int def) { + return static_cast(static_cast(param(p, id, static_cast(def)))); +} + +struct Result { + float peak = 0.0f; + float rms = 0.0f; + float masterLevel = 0.7f; +}; + +void renderPreset(const Preset& preset, Result& out) { + juce::Synthesiser synth; + synth.setCurrentPlaybackSampleRate(sampleRate); + synth.addSound(new SubtractiveSound()); + synth.addVoice(new SubtractiveVoice()); + auto* voice = dynamic_cast(synth.getVoice(0)); + + voice->setParameters( + static_cast(static_cast(param(preset, "osc1Wave", 1))), + static_cast(static_cast(param(preset, "osc2Wave", 2))), + param(preset, "osc1Oct", 0.0f), + param(preset, "osc2Oct", -1.0f), + param(preset, "osc1Semi", 0.0f), + param(preset, "osc2Semi", 0.0f), + param(preset, "osc1Fine", 0.0f), + param(preset, "osc2Fine", 7.0f), + param(preset, "osc1Level", 0.7f), + param(preset, "osc2Level", 0.7f), + param(preset, "phaseOffset", 0.5f), + param(preset, "filterCutoff", 8000.0f), + param(preset, "filterRes", 0.3f), + static_cast(static_cast(param(preset, "filterType", 0))), + param(preset, "filterEnvAmt", 0.0f), + param(preset, "keyTrack", 0.5f), + param(preset, "envAttack", 0.01f), + param(preset, "envDecay", 0.3f), + param(preset, "envSustain", 0.7f), + param(preset, "envRelease", 0.5f), + param(preset, "fEnvAttack", 0.01f), + param(preset, "fEnvDecay", 0.3f), + param(preset, "fEnvSustain", 0.5f), + param(preset, "fEnvRelease", 0.5f), + param(preset, "pan", 0.0f), + param(preset, "drive", 1.5f), + 1.0f, // outputLevel (master gain applied separately, see processBlock) + param(preset, "lfo1Rate", 2.0f), + param(preset, "lfo1Depth", 0.0f), + static_cast(paramInt(preset, "lfo1Shape", 0)), + static_cast(paramInt(preset, "lfo1Dest", 0)), + param(preset, "lfo2Rate", 2.0f), + param(preset, "lfo2Depth", 0.0f), + static_cast(paramInt(preset, "lfo2Shape", 0)), + static_cast(paramInt(preset, "lfo2Dest", 0))); + + Distortion distortion; + Compression compression; + Limiter limiter; + Delay delay; + ReverbFX reverb; + distortion.prepare(sampleRate); + compression.prepare(sampleRate); + limiter.prepare(sampleRate); + delay.prepare(sampleRate); + reverb.prepare(sampleRate); + + distortion.setParameters( + static_cast(static_cast(param(preset, "distType", 0))), + param(preset, "distAmount", 0.0f), + param(preset, "distSymmetry", 0.0f), + param(preset, "distTone", 1.0f)); + compression.setParameters( + param(preset, "compThreshold", -20.0f), + param(preset, "compRatio", 4.0f), + param(preset, "compAttack", 10.0f), + param(preset, "compRelease", 100.0f), + param(preset, "compMakeup", 0.0f)); + limiter.setParameters(1.0f, 0.9f, 50.0f); // plugin defaults (presets don't override) + delay.setParameters(param(preset, "delayTime", 200.0f), + param(preset, "delayFeedback", 0.0f), + param(preset, "delayMix", 0.0f), + param(preset, "delayPingPong", 0.0f) > 0.5f); + reverb.setParameters(param(preset, "reverbSize", 0.5f), + param(preset, "reverbDamping", 0.5f), + 0.8f, + param(preset, "reverbMix", 0.0f)); + + const float autoPanRate = param(preset, "autoPanRate", 2.0f); + const float autoPanDepth = param(preset, "autoPanDepth", 0.0f); + float autoPanPhase = 0.0f; + constexpr float twoPi = 6.2831853f; + + juce::AudioBuffer buffer(2, blockSize); + std::vector leftSamples, rightSamples; + const size_t capacity = static_cast((holdSeconds + tailSeconds) * sampleRate); + leftSamples.reserve(capacity); + rightSamples.reserve(capacity); + + auto renderAndApply = [&](double seconds) { + int total = static_cast(seconds * sampleRate); + int done = 0; + while (done < total) { + const int n = std::min(blockSize, total - done); + buffer.clear(); + juce::MidiBuffer midi; + synth.renderNextBlock(buffer, midi, 0, n); + + float* l = buffer.getWritePointer(0); + float* r = buffer.getWritePointer(1); + for (int i = 0; i < n; ++i) { + float left = l[i]; + float right = r[i]; + + left = distortion.process(left); + right = distortion.process(right); + left = compression.process(left); + right = compression.process(right); + left = limiter.process(left); + right = limiter.process(right); + + if (autoPanDepth > 0.001f) { + const float panLfo = std::sin(autoPanPhase * twoPi); + const float leftGain = 1.0f - autoPanDepth * 0.5f * (1.0f + panLfo); + const float rightGain = 1.0f - autoPanDepth * 0.5f * (1.0f - panLfo); + left *= leftGain; + right *= rightGain; + autoPanPhase += autoPanRate / static_cast(sampleRate); + if (autoPanPhase >= 1.0f) autoPanPhase -= 1.0f; + } + + delay.process(left, right); + l[i] = left; + r[i] = right; + } + + reverb.process(l, r, n); + for (int i = 0; i < n; ++i) { + leftSamples.push_back(l[i]); + rightSamples.push_back(r[i]); + } + done += n; + } + }; + + synth.noteOn(1, 60, 1.0f); + renderAndApply(holdSeconds); + synth.noteOff(1, 60, 0.0f, true); + renderAndApply(tailSeconds); + + float peak = 0.0f; + double sumSquares = 0.0; + for (size_t i = 0; i < leftSamples.size(); ++i) { + const float mix = (leftSamples[i] + rightSamples[i]) * 0.5f; + peak = std::max(peak, std::abs(mix)); + sumSquares += static_cast(mix) * mix; + } + + out.peak = peak; + out.rms = static_cast(std::sqrt(sumSquares / static_cast(leftSamples.size()))); + + // masterGain = masterLevel^2 (perceptual taper in processBlock). + // Pick the more conservative of the peak and RMS targets so loud presets + // are reined in on both fronts and nothing clips. + float masterLevel = 0.7f; + if (peak > 1.0e-4f) { + const float gainToPeak = targetPeak / peak; + const float gainToRms = out.rms > 1.0e-4f ? targetRms / out.rms : 1.0f; + const float gain = std::min(gainToPeak, gainToRms); + masterLevel = std::sqrt(std::min(gain, 1.0f)); + } + out.masterLevel = juce::jlimit(0.0f, 1.0f, masterLevel); +} + +std::string formatValue(float v) { + char buf[32]; + std::snprintf(buf, sizeof(buf), "%.3f", v); + std::string s(buf); + if (s.find('.') != std::string::npos) { + while (!s.empty() && s.back() == '0') s.pop_back(); + if (!s.empty() && s.back() == '.') s.pop_back(); + } + if (s.empty() || s == "-") return "0.0"; + if (s.find('.') == std::string::npos) s += ".0"; // keep a decimal point + return s; +} + +bool isNumberChar(char c) { + return (c >= '0' && c <= '9') || c == '.' || c == '-' || c == '+' || c == 'e' || c == 'E'; +} + +int applyToHeader(const std::vector& results) { + const char* path = "Source/PresetManager.h"; + std::ifstream in(path, std::ios::binary); + if (!in) { + std::fprintf(stderr, "could not open %s\n", path); + return 1; + } + std::stringstream ss; + ss << in.rdbuf(); + std::string content = ss.str(); + + const std::string marker = "\"masterLevel\""; + size_t pos = 0; + size_t idx = 0; + while ((pos = content.find(marker, pos)) != std::string::npos) { + const size_t comma = content.find(',', pos); + if (comma == std::string::npos) break; + size_t numStart = content.find_first_not_of(" \t", comma + 1); + if (numStart == std::string::npos) break; + size_t numEnd = numStart; + while (numEnd < content.size() && isNumberChar(content[numEnd])) ++numEnd; + + const bool hadF = numEnd < content.size() && (content[numEnd] == 'f' || content[numEnd] == 'F'); + const std::string token = content.substr(numStart, numEnd - numStart); + + float oldVal = 0.0f; + try { oldVal = std::stof(token); } catch (...) {} + + const float newVal = idx < results.size() ? results[idx].masterLevel : oldVal; + + std::string replacement = formatValue(newVal); + if (hadF) replacement += "f"; + + if (std::abs(oldVal - newVal) > 1.0e-4f) { + std::printf(" %s : %s -> %s\n", + marker.c_str(), token.c_str(), replacement.c_str()); + } + const size_t replaceEnd = numEnd + (hadF ? 1 : 0); + content.replace(numStart, replaceEnd - numStart, replacement); + pos = numStart + replacement.size(); + ++idx; + } + + if (idx != results.size()) { + std::fprintf(stderr, + "preset/masterLevel count mismatch (%zu presets, %zu entries) — aborting.\n", + results.size(), idx); + return 1; + } + + std::ofstream out(path, std::ios::binary | std::ios::trunc); + if (!out) { + std::fprintf(stderr, "could not write %s\n", path); + return 1; + } + out << content; + return 0; +} + +} // namespace + +int main(int argc, char** argv) { + const bool apply = argc > 1 && std::string(argv[1]) == "--apply"; + + PresetManager manager; + const auto& presets = manager.getPresets(); + std::vector results; + results.reserve(presets.size()); + + std::printf("%-22s %8s %8s %8s %8s\n", "PRESET", "PEAK", "RMS", "MASTER", "NEW"); + std::printf("%-22s %8s %8s %8s %8s\n", "------", "----", "---", "------", "---"); + + float minNew = 1.0f, maxNew = 0.0f; + for (const auto& preset : presets) { + Result res; + renderPreset(preset, res); + results.push_back(res); + + const float oldMaster = param(preset, "masterLevel", 0.7f); + minNew = std::min(minNew, res.masterLevel); + maxNew = std::max(maxNew, res.masterLevel); + + std::printf("%-22s %8.3f %8.3f %8.3f %8.3f\n", + preset.name.toRawUTF8(), res.peak, res.rms, oldMaster, res.masterLevel); + } + + std::printf("\n%zu presets measured. new masterLevel range: %.3f .. %.3f (peak %.2f, rms %.2f)\n", + presets.size(), minNew, maxNew, targetPeak, targetRms); + + if (apply) { + std::printf("\napplying changes to Source/PresetManager.h:\n"); + return applyToHeader(results); + } + + std::printf("\nrun with --apply to write the NEW column into PresetManager.h\n"); + return 0; +}