refactor(source): move every implementation into its module directory
- 36 files move into the module whose AGENTS.md already claimed them: Engine/, Synth/, Modulation/, Params/, Plugin/, GUI/, EffectUnits/, Resources/ - Source/engine, modulation, params, plugin and synth become Engine, Modulation, Params, Plugin and Synth, matching the directories that already hold code - ExactCompare.h stays at the Source/ root as the one shared header - SERUMALT_INCLUDE_DIRS adds one include directory per module, so the 31 parent-relative includes become plain names with no path prefix - the module AGENTS.md files list owned files instead of describing a move that had not happened, and README.md and AGENTS.md describe the real tree Verified: the harness passes CTest, the Linux VST3 and Standalone link, the Windows cross-build passes its module checks, each configure exposes only its own targets, no first-party warning line appears, and the generated Windows manifest is unchanged.
This commit is contained in:
biggy committed
1 parent
facd5c5b5e
commit
4b0db50271
70 files changed
+115
-111
No files matched your search
@@ -0,0 +1,42 @@
|
||||
# params module
|
||||
|
||||
## Owned files
|
||||
|
||||
- Params.h, Params.cpp
|
||||
|
||||
## Rules
|
||||
|
||||
- Use the `ids::` namespace for every APVTS parameter ID string.
|
||||
- Require one `ids::` entry per audio parameter, and one entry only.
|
||||
- Reach indexed parameters through the `paramIds::` arrays in `Params.h`, which pair each
|
||||
ID with its slot: `paramIds::oscillators`, `paramIds::envAttack`, `paramIds::lfoRate`,
|
||||
`paramIds::fxType`, `paramIds::macros` and their siblings. Use a single `ids::` entry only
|
||||
when the parameter has no index.
|
||||
- Use `enum class` for every enum. Give each a trailing `Count` enumerator.
|
||||
- Use `inline constexpr` for parameter ID strings and `k`-prefixed integer constants.
|
||||
- Keep all 0..1 to physical unit conversions in the `maps::` namespace.
|
||||
- Keep the wavetable name table (`kWavetableNames`) in sync with `kNumWavetables`.
|
||||
- Return an empty `juce::String` from enum-to-string switches for unknown values.
|
||||
- Never re-declare a parameter ID string literal outside Params.h.
|
||||
- Never add a physical unit mapping anywhere but `maps::`.
|
||||
|
||||
## IF-THEN
|
||||
|
||||
- IF you add an audio parameter THEN add its ID to `ids::` and, when it has physical units, add its mapping to `maps::` before any engine or GUI code reads it.
|
||||
- IF a switch converts an enum to a string THEN include a default case that returns an empty string.
|
||||
|
||||
## Examples
|
||||
|
||||
```cpp
|
||||
// BAD: re-declares the ID and drifts from Params.h
|
||||
if (auto* p = apvts.getParameter ("f1Cutoff"))
|
||||
return p->getValue();
|
||||
```
|
||||
|
||||
```cpp
|
||||
// GOOD: one source of truth
|
||||
if (auto* p = apvts.getParameter (ids::f1Cutoff))
|
||||
return p->getValue();
|
||||
```
|
||||
|
||||
This file overrides /AGENTS.md where they conflict.
|
||||
@@ -0,0 +1,162 @@
|
||||
#include "Params.h"
|
||||
|
||||
namespace serum
|
||||
{
|
||||
|
||||
juce::String modSourceName (ModSource s)
|
||||
{
|
||||
switch (s)
|
||||
{
|
||||
case ModSource::Lfo1: return "LFO 1";
|
||||
case ModSource::Lfo2: return "LFO 2";
|
||||
case ModSource::Lfo3: return "LFO 3";
|
||||
case ModSource::Lfo4: return "LFO 4";
|
||||
case ModSource::Env1: return "Env 1";
|
||||
case ModSource::Env2: return "Env 2";
|
||||
case ModSource::Env3: return "Env 3";
|
||||
case ModSource::Env4: return "Env 4";
|
||||
case ModSource::Velocity: return "Velocity";
|
||||
case ModSource::Note: return "Note";
|
||||
case ModSource::ModWheel: return "Mod Wheel";
|
||||
case ModSource::PitchBend: return "Pitch Bend";
|
||||
case ModSource::Macro1: return "Macro 1";
|
||||
case ModSource::Macro2: return "Macro 2";
|
||||
case ModSource::Macro3: return "Macro 3";
|
||||
case ModSource::Macro4: return "Macro 4";
|
||||
case ModSource::Random: return "Random";
|
||||
case ModSource::Count: return {};
|
||||
default: return {};
|
||||
}
|
||||
}
|
||||
|
||||
juce::String modSourceToString (ModSource s)
|
||||
{
|
||||
switch (s)
|
||||
{
|
||||
case ModSource::Lfo1: return "lfo1"; case ModSource::Lfo2: return "lfo2";
|
||||
case ModSource::Lfo3: return "lfo3"; case ModSource::Lfo4: return "lfo4";
|
||||
case ModSource::Env1: return "env1"; case ModSource::Env2: return "env2";
|
||||
case ModSource::Env3: return "env3"; case ModSource::Env4: return "env4";
|
||||
case ModSource::Velocity: return "velocity"; case ModSource::Note: return "note";
|
||||
case ModSource::ModWheel: return "modwheel"; case ModSource::PitchBend: return "pitchbend";
|
||||
case ModSource::Macro1: return "macro1"; case ModSource::Macro2: return "macro2";
|
||||
case ModSource::Macro3: return "macro3"; case ModSource::Macro4: return "macro4";
|
||||
case ModSource::Random: return "random";
|
||||
case ModSource::Count: return {};
|
||||
default: return {};
|
||||
}
|
||||
}
|
||||
|
||||
ModSource modSourceFromString (const juce::String& s)
|
||||
{
|
||||
for (int i = 0; i < kNumModSources; ++i)
|
||||
if (s == modSourceToString ((ModSource) i))
|
||||
return (ModSource) i;
|
||||
return ModSource::Count;
|
||||
}
|
||||
|
||||
juce::String modTargetName (ModTarget t)
|
||||
{
|
||||
switch (t)
|
||||
{
|
||||
case ModTarget::Master: return "Master Volume";
|
||||
case ModTarget::Pitch: return "Pitch";
|
||||
case ModTarget::Amp: return "Amp";
|
||||
case ModTarget::OscALevel: return "Osc A Level";
|
||||
case ModTarget::OscAPan: return "Osc A Pan";
|
||||
case ModTarget::OscAWtPos: return "Osc A WT Pos";
|
||||
case ModTarget::OscAUnison: return "Osc A Unison";
|
||||
case ModTarget::OscADetune: return "Osc A Detune";
|
||||
case ModTarget::OscASpread: return "Osc A Spread";
|
||||
case ModTarget::OscAWarpAmt: return "Osc A Warp Amt";
|
||||
case ModTarget::OscBLevel: return "Osc B Level";
|
||||
case ModTarget::OscBPan: return "Osc B Pan";
|
||||
case ModTarget::OscBWtPos: return "Osc B WT Pos";
|
||||
case ModTarget::OscBUnison: return "Osc B Unison";
|
||||
case ModTarget::OscBDetune: return "Osc B Detune";
|
||||
case ModTarget::OscBSpread: return "Osc B Spread";
|
||||
case ModTarget::OscBWarpAmt: return "Osc B Warp Amt";
|
||||
case ModTarget::SubLevel: return "Sub Level";
|
||||
case ModTarget::NoiseLevel: return "Noise Level";
|
||||
case ModTarget::Filter1Cutoff: return "Filter 1 Cutoff";
|
||||
case ModTarget::Filter1Res: return "Filter 1 Res";
|
||||
case ModTarget::Filter1Drive: return "Filter 1 Drive";
|
||||
case ModTarget::Filter2Cutoff: return "Filter 2 Cutoff";
|
||||
case ModTarget::Filter2Res: return "Filter 2 Res";
|
||||
case ModTarget::Filter2Drive: return "Filter 2 Drive";
|
||||
case ModTarget::FilterMix: return "Filter Mix";
|
||||
case ModTarget::FilterOut: return "Filter Out";
|
||||
case ModTarget::Fx1Mix: return "FX 1 Mix"; case ModTarget::Fx2Mix: return "FX 2 Mix";
|
||||
case ModTarget::Fx3Mix: return "FX 3 Mix"; case ModTarget::Fx4Mix: return "FX 4 Mix";
|
||||
case ModTarget::Fx5Mix: return "FX 5 Mix"; case ModTarget::Fx6Mix: return "FX 6 Mix";
|
||||
case ModTarget::Fx7Mix: return "FX 7 Mix"; case ModTarget::Fx8Mix: return "FX 8 Mix";
|
||||
case ModTarget::None: return {};
|
||||
case ModTarget::Count: return {};
|
||||
default: return {};
|
||||
}
|
||||
}
|
||||
|
||||
juce::String modTargetParamId (ModTarget t)
|
||||
{
|
||||
switch (t)
|
||||
{
|
||||
case ModTarget::Master: return ids::master;
|
||||
case ModTarget::Pitch: return {};
|
||||
case ModTarget::Amp: return {};
|
||||
case ModTarget::OscALevel: return ids::oscALevel;
|
||||
case ModTarget::OscAPan: return ids::oscAPan;
|
||||
case ModTarget::OscAWtPos: return ids::oscAWtPos;
|
||||
case ModTarget::OscAUnison: return ids::oscAUnison;
|
||||
case ModTarget::OscADetune: return ids::oscADetune;
|
||||
case ModTarget::OscASpread: return ids::oscASpread;
|
||||
case ModTarget::OscAWarpAmt: return ids::oscAWarpAmt;
|
||||
case ModTarget::OscBLevel: return ids::oscBLevel;
|
||||
case ModTarget::OscBPan: return ids::oscBPan;
|
||||
case ModTarget::OscBWtPos: return ids::oscBWtPos;
|
||||
case ModTarget::OscBUnison: return ids::oscBUnison;
|
||||
case ModTarget::OscBDetune: return ids::oscBDetune;
|
||||
case ModTarget::OscBSpread: return ids::oscBSpread;
|
||||
case ModTarget::OscBWarpAmt: return ids::oscBWarpAmt;
|
||||
case ModTarget::SubLevel: return ids::subLevel;
|
||||
case ModTarget::NoiseLevel: return ids::noiseLevel;
|
||||
case ModTarget::Filter1Cutoff: return ids::f1Cutoff;
|
||||
case ModTarget::Filter1Res: return ids::f1Res;
|
||||
case ModTarget::Filter1Drive: return ids::f1Drive;
|
||||
case ModTarget::Filter2Cutoff: return ids::f2Cutoff;
|
||||
case ModTarget::Filter2Res: return ids::f2Res;
|
||||
case ModTarget::Filter2Drive: return ids::f2Drive;
|
||||
case ModTarget::FilterMix: return ids::fMix;
|
||||
case ModTarget::FilterOut: return ids::fOut;
|
||||
case ModTarget::Fx1Mix: return ids::fx1Mix; case ModTarget::Fx2Mix: return ids::fx2Mix;
|
||||
case ModTarget::Fx3Mix: return ids::fx3Mix; case ModTarget::Fx4Mix: return ids::fx4Mix;
|
||||
case ModTarget::Fx5Mix: return ids::fx5Mix; case ModTarget::Fx6Mix: return ids::fx6Mix;
|
||||
case ModTarget::Fx7Mix: return ids::fx7Mix; case ModTarget::Fx8Mix: return ids::fx8Mix;
|
||||
case ModTarget::None: return {};
|
||||
case ModTarget::Count: return {};
|
||||
default: return {};
|
||||
}
|
||||
}
|
||||
|
||||
ModTarget modTargetFromParamId (const juce::String& id)
|
||||
{
|
||||
for (int i = 0; i < kNumModTargets; ++i)
|
||||
if (id.isNotEmpty() && modTargetParamId ((ModTarget) i) == id)
|
||||
return (ModTarget) i;
|
||||
return ModTarget::None;
|
||||
}
|
||||
|
||||
juce::String modTargetToString (ModTarget t)
|
||||
{
|
||||
if (t == ModTarget::Pitch) return "pitch";
|
||||
if (t == ModTarget::Amp) return "amp";
|
||||
return modTargetParamId (t);
|
||||
}
|
||||
|
||||
ModTarget modTargetFromString (const juce::String& s)
|
||||
{
|
||||
if (s == "pitch") return ModTarget::Pitch;
|
||||
if (s == "amp") return ModTarget::Amp;
|
||||
return modTargetFromParamId (s);
|
||||
}
|
||||
|
||||
} // namespace serum
|
||||
@@ -0,0 +1,388 @@
|
||||
#pragma once
|
||||
|
||||
#include <JuceHeader.h>
|
||||
|
||||
// ===========================================================================
|
||||
// Central registry of parameter IDs, enums and mapping helpers for SerumAlt.
|
||||
// Every audio parameter (APVTS) and every modulation destination is declared
|
||||
// here so that the DSP engine, the mod matrix and the GUI share one source of
|
||||
// truth.
|
||||
// ===========================================================================
|
||||
|
||||
namespace serum
|
||||
{
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Parameter IDs (APVTS)
|
||||
// ---------------------------------------------------------------------------
|
||||
namespace ids
|
||||
{
|
||||
// Global
|
||||
inline constexpr const char* master = "master";
|
||||
inline constexpr const char* uiScale = "uiScale";
|
||||
inline constexpr const char* rave = "rave";
|
||||
|
||||
// Oscillator A / B
|
||||
inline constexpr const char* oscAOn = "oscAOn";
|
||||
inline constexpr const char* oscAWave = "oscAWave";
|
||||
inline constexpr const char* oscAWtPos = "oscAWtPos";
|
||||
inline constexpr const char* oscAWarp = "oscAWarp";
|
||||
inline constexpr const char* oscAWarpAmt = "oscAWarpAmt";
|
||||
inline constexpr const char* oscACoarse = "oscACoarse";
|
||||
inline constexpr const char* oscAFine = "oscAFine";
|
||||
inline constexpr const char* oscALevel = "oscALevel";
|
||||
inline constexpr const char* oscAPan = "oscAPan";
|
||||
inline constexpr const char* oscAUnison = "oscAUnison";
|
||||
inline constexpr const char* oscADetune = "oscADetune";
|
||||
inline constexpr const char* oscASpread = "oscASpread";
|
||||
inline constexpr const char* oscAPhase = "oscAPhase";
|
||||
inline constexpr const char* oscARandPh = "oscARandPh";
|
||||
|
||||
inline constexpr const char* oscBOn = "oscBOn";
|
||||
inline constexpr const char* oscBWave = "oscBWave";
|
||||
inline constexpr const char* oscBWtPos = "oscBWtPos";
|
||||
inline constexpr const char* oscBWarp = "oscBWarp";
|
||||
inline constexpr const char* oscBWarpAmt = "oscBWarpAmt";
|
||||
inline constexpr const char* oscBCoarse = "oscBCoarse";
|
||||
inline constexpr const char* oscBFine = "oscBFine";
|
||||
inline constexpr const char* oscBLevel = "oscBLevel";
|
||||
inline constexpr const char* oscBPan = "oscBPan";
|
||||
inline constexpr const char* oscBUnison = "oscBUnison";
|
||||
inline constexpr const char* oscBDetune = "oscBDetune";
|
||||
inline constexpr const char* oscBSpread = "oscBSpread";
|
||||
inline constexpr const char* oscBPhase = "oscBPhase";
|
||||
inline constexpr const char* oscBRandPh = "oscBRandPh";
|
||||
|
||||
// Sub oscillator
|
||||
inline constexpr const char* subOn = "subOn";
|
||||
inline constexpr const char* subShape = "subShape";
|
||||
inline constexpr const char* subOct = "subOct";
|
||||
inline constexpr const char* subLevel = "subLevel";
|
||||
|
||||
// Noise
|
||||
inline constexpr const char* noiseOn = "noiseOn";
|
||||
inline constexpr const char* noiseType = "noiseType";
|
||||
inline constexpr const char* noiseLevel = "noiseLevel";
|
||||
|
||||
// Filters
|
||||
inline constexpr const char* f1On = "f1On";
|
||||
inline constexpr const char* f1Type = "f1Type";
|
||||
inline constexpr const char* f1Cutoff = "f1Cutoff";
|
||||
inline constexpr const char* f1Res = "f1Res";
|
||||
inline constexpr const char* f1Drive = "f1Drive";
|
||||
inline constexpr const char* f1Key = "f1Key";
|
||||
inline constexpr const char* f1Slope = "f1Slope";
|
||||
|
||||
inline constexpr const char* f2On = "f2On";
|
||||
inline constexpr const char* f2Type = "f2Type";
|
||||
inline constexpr const char* f2Cutoff = "f2Cutoff";
|
||||
inline constexpr const char* f2Res = "f2Res";
|
||||
inline constexpr const char* f2Drive = "f2Drive";
|
||||
inline constexpr const char* f2Key = "f2Key";
|
||||
inline constexpr const char* f2Slope = "f2Slope";
|
||||
|
||||
inline constexpr const char* fRoute = "fRoute";
|
||||
inline constexpr const char* fMix = "fMix";
|
||||
inline constexpr const char* fOut = "fOut";
|
||||
|
||||
// Envelopes 1..4
|
||||
inline constexpr const char* env1A = "env1A";
|
||||
inline constexpr const char* env1D = "env1D";
|
||||
inline constexpr const char* env1S = "env1S";
|
||||
inline constexpr const char* env1R = "env1R";
|
||||
inline constexpr const char* env1Curve = "env1Curve";
|
||||
|
||||
inline constexpr const char* env2A = "env2A";
|
||||
inline constexpr const char* env2D = "env2D";
|
||||
inline constexpr const char* env2S = "env2S";
|
||||
inline constexpr const char* env2R = "env2R";
|
||||
inline constexpr const char* env2Curve = "env2Curve";
|
||||
|
||||
inline constexpr const char* env3A = "env3A";
|
||||
inline constexpr const char* env3D = "env3D";
|
||||
inline constexpr const char* env3S = "env3S";
|
||||
inline constexpr const char* env3R = "env3R";
|
||||
inline constexpr const char* env3Curve = "env3Curve";
|
||||
|
||||
inline constexpr const char* env4A = "env4A";
|
||||
inline constexpr const char* env4D = "env4D";
|
||||
inline constexpr const char* env4S = "env4S";
|
||||
inline constexpr const char* env4R = "env4R";
|
||||
inline constexpr const char* env4Curve = "env4Curve";
|
||||
|
||||
// LFOs 1..4
|
||||
inline constexpr const char* lfo1Rate = "lfo1Rate";
|
||||
inline constexpr const char* lfo1Sync = "lfo1Sync";
|
||||
inline constexpr const char* lfo1Beat = "lfo1Beat";
|
||||
inline constexpr const char* lfo1Shape = "lfo1Shape";
|
||||
inline constexpr const char* lfo1Phase = "lfo1Phase";
|
||||
inline constexpr const char* lfo1Fade = "lfo1Fade";
|
||||
inline constexpr const char* lfo1Delay = "lfo1Delay";
|
||||
|
||||
inline constexpr const char* lfo2Rate = "lfo2Rate";
|
||||
inline constexpr const char* lfo2Sync = "lfo2Sync";
|
||||
inline constexpr const char* lfo2Beat = "lfo2Beat";
|
||||
inline constexpr const char* lfo2Shape = "lfo2Shape";
|
||||
inline constexpr const char* lfo2Phase = "lfo2Phase";
|
||||
inline constexpr const char* lfo2Fade = "lfo2Fade";
|
||||
inline constexpr const char* lfo2Delay = "lfo2Delay";
|
||||
|
||||
inline constexpr const char* lfo3Rate = "lfo3Rate";
|
||||
inline constexpr const char* lfo3Sync = "lfo3Sync";
|
||||
inline constexpr const char* lfo3Beat = "lfo3Beat";
|
||||
inline constexpr const char* lfo3Shape = "lfo3Shape";
|
||||
inline constexpr const char* lfo3Phase = "lfo3Phase";
|
||||
inline constexpr const char* lfo3Fade = "lfo3Fade";
|
||||
inline constexpr const char* lfo3Delay = "lfo3Delay";
|
||||
|
||||
inline constexpr const char* lfo4Rate = "lfo4Rate";
|
||||
inline constexpr const char* lfo4Sync = "lfo4Sync";
|
||||
inline constexpr const char* lfo4Beat = "lfo4Beat";
|
||||
inline constexpr const char* lfo4Shape = "lfo4Shape";
|
||||
inline constexpr const char* lfo4Phase = "lfo4Phase";
|
||||
inline constexpr const char* lfo4Fade = "lfo4Fade";
|
||||
inline constexpr const char* lfo4Delay = "lfo4Delay";
|
||||
|
||||
// FX slots (8)
|
||||
inline constexpr const char* fx1Type = "fx1Type";
|
||||
inline constexpr const char* fx1Mix = "fx1Mix";
|
||||
inline constexpr const char* fx1P1 = "fx1P1";
|
||||
inline constexpr const char* fx1P2 = "fx1P2";
|
||||
inline constexpr const char* fx1P3 = "fx1P3";
|
||||
inline constexpr const char* fx1P4 = "fx1P4";
|
||||
|
||||
inline constexpr const char* fx2Type = "fx2Type";
|
||||
inline constexpr const char* fx2Mix = "fx2Mix";
|
||||
inline constexpr const char* fx2P1 = "fx2P1";
|
||||
inline constexpr const char* fx2P2 = "fx2P2";
|
||||
inline constexpr const char* fx2P3 = "fx2P3";
|
||||
inline constexpr const char* fx2P4 = "fx2P4";
|
||||
|
||||
inline constexpr const char* fx3Type = "fx3Type";
|
||||
inline constexpr const char* fx3Mix = "fx3Mix";
|
||||
inline constexpr const char* fx3P1 = "fx3P1";
|
||||
inline constexpr const char* fx3P2 = "fx3P2";
|
||||
inline constexpr const char* fx3P3 = "fx3P3";
|
||||
inline constexpr const char* fx3P4 = "fx3P4";
|
||||
|
||||
inline constexpr const char* fx4Type = "fx4Type";
|
||||
inline constexpr const char* fx4Mix = "fx4Mix";
|
||||
inline constexpr const char* fx4P1 = "fx4P1";
|
||||
inline constexpr const char* fx4P2 = "fx4P2";
|
||||
inline constexpr const char* fx4P3 = "fx4P3";
|
||||
inline constexpr const char* fx4P4 = "fx4P4";
|
||||
|
||||
inline constexpr const char* fx5Type = "fx5Type";
|
||||
inline constexpr const char* fx5Mix = "fx5Mix";
|
||||
inline constexpr const char* fx5P1 = "fx5P1";
|
||||
inline constexpr const char* fx5P2 = "fx5P2";
|
||||
inline constexpr const char* fx5P3 = "fx5P3";
|
||||
inline constexpr const char* fx5P4 = "fx5P4";
|
||||
|
||||
inline constexpr const char* fx6Type = "fx6Type";
|
||||
inline constexpr const char* fx6Mix = "fx6Mix";
|
||||
inline constexpr const char* fx6P1 = "fx6P1";
|
||||
inline constexpr const char* fx6P2 = "fx6P2";
|
||||
inline constexpr const char* fx6P3 = "fx6P3";
|
||||
inline constexpr const char* fx6P4 = "fx6P4";
|
||||
|
||||
inline constexpr const char* fx7Type = "fx7Type";
|
||||
inline constexpr const char* fx7Mix = "fx7Mix";
|
||||
inline constexpr const char* fx7P1 = "fx7P1";
|
||||
inline constexpr const char* fx7P2 = "fx7P2";
|
||||
inline constexpr const char* fx7P3 = "fx7P3";
|
||||
inline constexpr const char* fx7P4 = "fx7P4";
|
||||
|
||||
inline constexpr const char* fx8Type = "fx8Type";
|
||||
inline constexpr const char* fx8Mix = "fx8Mix";
|
||||
inline constexpr const char* fx8P1 = "fx8P1";
|
||||
inline constexpr const char* fx8P2 = "fx8P2";
|
||||
inline constexpr const char* fx8P3 = "fx8P3";
|
||||
inline constexpr const char* fx8P4 = "fx8P4";
|
||||
|
||||
// Macros 1..4
|
||||
inline constexpr const char* macro1 = "macro1";
|
||||
inline constexpr const char* macro2 = "macro2";
|
||||
inline constexpr const char* macro3 = "macro3";
|
||||
inline constexpr const char* macro4 = "macro4";
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Enums
|
||||
// ---------------------------------------------------------------------------
|
||||
enum class WarpMode : int { None = 0, BendPlus, BendMinus, Sync, PWM, Asym, Mirror, Fold, Count };
|
||||
enum class SubShape : int { Sine = 0, Triangle, Count };
|
||||
enum class NoiseType : int { White = 0, Pink, Count };
|
||||
enum class FilterModel: int { LadderLP = 0, LadderHP, LadderBP, Diode, Comb, Formant, Screamer, Count };
|
||||
enum class FilterRoute: int { Serial = 0, Parallel, Split, Count };
|
||||
enum class LfoShape : int { Sine = 0, Triangle, Saw, Square, SampleHold, StepSeq, Freehand, Count };
|
||||
enum class FxType : int { Off = 0, Hyper, Chorus, Flanger, Phaser, Distortion, EQ, Compressor, Delay, Reverb, Count };
|
||||
|
||||
inline constexpr int kNumOscillators = 2;
|
||||
inline constexpr int kNumEnvelopes = 4;
|
||||
inline constexpr int kNumLfos = 4;
|
||||
inline constexpr int kNumMacros = 4;
|
||||
inline constexpr int kNumFxSlots = 8;
|
||||
inline constexpr int kMaxUnison = 16;
|
||||
inline constexpr int kNumVoices = 32;
|
||||
|
||||
namespace paramIds
|
||||
{
|
||||
struct Oscillator
|
||||
{
|
||||
const char *on, *wave, *wtPos, *warp, *warpAmt, *coarse, *fine, *level;
|
||||
const char *pan, *unison, *detune, *spread, *phase, *randPhase;
|
||||
};
|
||||
|
||||
inline constexpr Oscillator oscillators[kNumOscillators] = {
|
||||
{ ids::oscAOn, ids::oscAWave, ids::oscAWtPos, ids::oscAWarp, ids::oscAWarpAmt,
|
||||
ids::oscACoarse, ids::oscAFine, ids::oscALevel, ids::oscAPan, ids::oscAUnison,
|
||||
ids::oscADetune, ids::oscASpread, ids::oscAPhase, ids::oscARandPh },
|
||||
{ ids::oscBOn, ids::oscBWave, ids::oscBWtPos, ids::oscBWarp, ids::oscBWarpAmt,
|
||||
ids::oscBCoarse, ids::oscBFine, ids::oscBLevel, ids::oscBPan, ids::oscBUnison,
|
||||
ids::oscBDetune, ids::oscBSpread, ids::oscBPhase, ids::oscBRandPh }
|
||||
};
|
||||
|
||||
inline constexpr const char* envAttack[] = { ids::env1A, ids::env2A, ids::env3A, ids::env4A };
|
||||
inline constexpr const char* envDecay[] = { ids::env1D, ids::env2D, ids::env3D, ids::env4D };
|
||||
inline constexpr const char* envSustain[] = { ids::env1S, ids::env2S, ids::env3S, ids::env4S };
|
||||
inline constexpr const char* envRelease[] = { ids::env1R, ids::env2R, ids::env3R, ids::env4R };
|
||||
inline constexpr const char* envCurve[] = { ids::env1Curve, ids::env2Curve, ids::env3Curve, ids::env4Curve };
|
||||
inline constexpr const char* lfoRate[] = { ids::lfo1Rate, ids::lfo2Rate, ids::lfo3Rate, ids::lfo4Rate };
|
||||
inline constexpr const char* lfoSync[] = { ids::lfo1Sync, ids::lfo2Sync, ids::lfo3Sync, ids::lfo4Sync };
|
||||
inline constexpr const char* lfoBeat[] = { ids::lfo1Beat, ids::lfo2Beat, ids::lfo3Beat, ids::lfo4Beat };
|
||||
inline constexpr const char* lfoShape[] = { ids::lfo1Shape, ids::lfo2Shape, ids::lfo3Shape, ids::lfo4Shape };
|
||||
inline constexpr const char* lfoPhase[] = { ids::lfo1Phase, ids::lfo2Phase, ids::lfo3Phase, ids::lfo4Phase };
|
||||
inline constexpr const char* lfoFade[] = { ids::lfo1Fade, ids::lfo2Fade, ids::lfo3Fade, ids::lfo4Fade };
|
||||
inline constexpr const char* lfoDelay[] = { ids::lfo1Delay, ids::lfo2Delay, ids::lfo3Delay, ids::lfo4Delay };
|
||||
inline constexpr const char* fxType[] = { ids::fx1Type, ids::fx2Type, ids::fx3Type, ids::fx4Type,
|
||||
ids::fx5Type, ids::fx6Type, ids::fx7Type, ids::fx8Type };
|
||||
inline constexpr const char* fxMix[] = { ids::fx1Mix, ids::fx2Mix, ids::fx3Mix, ids::fx4Mix,
|
||||
ids::fx5Mix, ids::fx6Mix, ids::fx7Mix, ids::fx8Mix };
|
||||
inline constexpr const char* fxP1[] = { ids::fx1P1, ids::fx2P1, ids::fx3P1, ids::fx4P1,
|
||||
ids::fx5P1, ids::fx6P1, ids::fx7P1, ids::fx8P1 };
|
||||
inline constexpr const char* fxP2[] = { ids::fx1P2, ids::fx2P2, ids::fx3P2, ids::fx4P2,
|
||||
ids::fx5P2, ids::fx6P2, ids::fx7P2, ids::fx8P2 };
|
||||
inline constexpr const char* fxP3[] = { ids::fx1P3, ids::fx2P3, ids::fx3P3, ids::fx4P3,
|
||||
ids::fx5P3, ids::fx6P3, ids::fx7P3, ids::fx8P3 };
|
||||
inline constexpr const char* fxP4[] = { ids::fx1P4, ids::fx2P4, ids::fx3P4, ids::fx4P4,
|
||||
ids::fx5P4, ids::fx6P4, ids::fx7P4, ids::fx8P4 };
|
||||
inline constexpr const char* macros[] = { ids::macro1, ids::macro2, ids::macro3, ids::macro4 };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Modulation sources / destinations
|
||||
// ---------------------------------------------------------------------------
|
||||
enum class ModSource : int
|
||||
{
|
||||
Lfo1 = 0, Lfo2, Lfo3, Lfo4,
|
||||
Env1, Env2, Env3, Env4,
|
||||
Velocity, Note, ModWheel, PitchBend,
|
||||
Macro1, Macro2, Macro3, Macro4,
|
||||
Random,
|
||||
Count
|
||||
};
|
||||
|
||||
enum class ModTarget : int
|
||||
{
|
||||
None = -1,
|
||||
Master = 0,
|
||||
Pitch,
|
||||
Amp,
|
||||
OscALevel, OscAPan, OscAWtPos, OscAUnison, OscADetune, OscASpread, OscAWarpAmt,
|
||||
OscBLevel, OscBPan, OscBWtPos, OscBUnison, OscBDetune, OscBSpread, OscBWarpAmt,
|
||||
SubLevel, NoiseLevel,
|
||||
Filter1Cutoff, Filter1Res, Filter1Drive,
|
||||
Filter2Cutoff, Filter2Res, Filter2Drive,
|
||||
FilterMix, FilterOut,
|
||||
Fx1Mix, Fx2Mix, Fx3Mix, Fx4Mix, Fx5Mix, Fx6Mix, Fx7Mix, Fx8Mix,
|
||||
Count
|
||||
};
|
||||
|
||||
inline constexpr int kNumModTargets = (int) ModTarget::Count;
|
||||
inline constexpr int kNumModSources = (int) ModSource::Count;
|
||||
|
||||
// Is a given source per-voice (i.e. needs a value for each voice)?
|
||||
inline bool isPerVoiceSource (ModSource s)
|
||||
{
|
||||
return (s >= ModSource::Env1 && s <= ModSource::Note) || s == ModSource::Random;
|
||||
}
|
||||
|
||||
// Does a source already span -1..1 (bipolar range)?
|
||||
inline bool isBipolarSource (ModSource s)
|
||||
{
|
||||
return (s >= ModSource::Lfo1 && s <= ModSource::Lfo4) || s == ModSource::PitchBend;
|
||||
}
|
||||
|
||||
// Is a given target a per-voice parameter?
|
||||
inline bool isPerVoiceTarget (ModTarget t)
|
||||
{
|
||||
return t != ModTarget::Master && ! (t >= ModTarget::Fx1Mix && t <= ModTarget::Fx8Mix);
|
||||
}
|
||||
|
||||
juce::String modSourceName (ModSource s);
|
||||
juce::String modTargetName (ModTarget t);
|
||||
juce::String modTargetParamId(ModTarget t); // APVTS param id for the target
|
||||
ModTarget modTargetFromParamId (const juce::String& id);
|
||||
ModSource modSourceFromString (const juce::String& s);
|
||||
juce::String modSourceToString (ModSource s);
|
||||
juce::String modTargetToString (ModTarget t);
|
||||
ModTarget modTargetFromString (const juce::String& s);
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Mapping helpers (raw 0..1 <-> physical units)
|
||||
// ---------------------------------------------------------------------------
|
||||
namespace maps
|
||||
{
|
||||
// Envelope times: 0..1 -> 0.5ms .. 12s (cubic taper for fine control at short times)
|
||||
inline float toSeconds (float x) { return 0.0005f + std::pow (juce::jlimit (0.0f, 1.0f, x), 3.0f) * 12.0f; }
|
||||
inline float fromSeconds (float s) { return std::pow (juce::jlimit (0.0005f, 12.0f, s) / 12.0f, 1.0f / 3.0f); }
|
||||
|
||||
// Cutoff: 0..1 -> 20Hz .. 20kHz (log)
|
||||
inline float cutoffToHz (float x) { return 20.0f * std::pow (1000.0f, juce::jlimit (0.0f, 1.0f, x)); }
|
||||
inline float hzToCutoff (float hz) { return std::log (juce::jlimit (20.0f, 20000.0f, hz) / 20.0f) / std::log (1000.0f); }
|
||||
|
||||
// LFO rate: 0..1 -> 0.02Hz .. 30Hz (log)
|
||||
inline float rateToHz (float x) { return 0.02f * std::pow (1500.0f, juce::jlimit (0.0f, 1.0f, x)); }
|
||||
inline float hzToRate (float hz) { return std::log (juce::jlimit (0.02f, 30.0f, hz) / 0.02f) / std::log (1500.0f); }
|
||||
|
||||
// LFO beat division: 0..1 -> 1/32 .. 4 bars (log stepped)
|
||||
inline float beatToMultiplier (float x)
|
||||
{
|
||||
// 0 -> 1/32, 0.5 -> 1/4, 1 -> 4 bars
|
||||
static constexpr float divisions[16] =
|
||||
{
|
||||
1.0f/32.0f, 1.0f/16.0f, 1.0f/8.0f, 1.0f/6.0f, 1.0f/4.0f, 1.0f/3.0f,
|
||||
1.0f/2.0f, 1.0f, 3.0f/2.0f, 2.0f, 3.0f, 4.0f, 6.0f, 8.0f, 12.0f, 16.0f
|
||||
};
|
||||
const int idx = juce::jlimit (0, 15, (int) std::llround (x * 15.0f));
|
||||
return divisions[idx];
|
||||
}
|
||||
|
||||
// FX delay time: 0..1 -> 1ms .. 2000ms (log)
|
||||
inline float delayToMs (float x) { return 1.0f * std::pow (2000.0f, juce::jlimit (0.0f, 1.0f, x)); }
|
||||
inline float msToDelay (float ms) { return std::log (juce::jlimit (1.0f, 2000.0f, ms)) / std::log (2000.0f); }
|
||||
|
||||
// Reverb size: 0..1 -> 0.2 .. 0.99
|
||||
inline float sizeToValue (float x) { return 0.2f + juce::jlimit (0.0f, 1.0f, x) * 0.79f; }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Factory wavetable names (index == oscWave param value)
|
||||
// ---------------------------------------------------------------------------
|
||||
inline const char* const kWavetableNames[] =
|
||||
{
|
||||
"Basic Shapes",
|
||||
"Saw PWM",
|
||||
"Square Sync",
|
||||
"Triangle Fold",
|
||||
"Vowel",
|
||||
"Organ",
|
||||
"Warm Saw",
|
||||
"Digital",
|
||||
"Glass",
|
||||
"Bass"
|
||||
};
|
||||
inline constexpr int kNumWavetables = 10;
|
||||
|
||||
} // namespace serum
|
||||
Reference in new issue
Block a user