diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_BLOCK_DIAGRAM.html b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_BLOCK_DIAGRAM.html new file mode 100644 index 000000000..d542861b5 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_BLOCK_DIAGRAM.html @@ -0,0 +1,420 @@ + + + + + + CloudSeedCore Interactive Block Diagram + + + +
+

CloudSeedCore ↔ Daisy Interactive Block Diagram

+

Click blocks in the signal flow to jump to DSP primitives and parameter ownership.

+
+ +
+
+

Signal Flow (Interactive)

+
+
+ + + + + + + + + + + Input L/R + + + + + Input Mix + + HPF / LPF + (Global) + + + + + Multitap + Reflections + + + + + Early Diffusion + Allpass Network + + + + + Late Reverb Core + Delay Bank + Matrix + + Mod + Decay + + + + + Output EQ + Shelves + LPF + + + + + Dry/Early/Late + Output Mix + + + + + Seed / Randomization + Tap/Diff/Delay/Post + + + + + + + + + + + + + +

Legend: blue boxes = audio path, green-highlight on click = selected block details.

+
+
+ +
+

Block Internals + Controls

+
+ +
+ Input Stage +

Purpose: ingest stereo/mono, normalize gain staging before cloud network.

+
    +
  • Primitives: input gain, channel sum/split, soft clip (optional).
    • +
  • Key runtime class candidate: InputRouter.
    • +
+
+ +
+ Global Preconditioning +
    +
  • Primitives: one-pole/biquad HPF + LPF, interpolation mode, pre-wet gain trim.
    • +
  • Class candidate: InputConditioner.
    • +
+ + + +
Control GroupParameters
CloudSeedGlobalINTERPOLATION_PARAM, INPUT_MIX_PARAM, LOW_CUT_ENABLED_PARAM, LOW_CUT_PARAM, HIGH_CUT_ENABLED_PARAM, HIGH_CUT_PARAM
+
+ +
+ Multitap Reflections +
    +
  • Primitives: parallel short delay lines, per-tap gain law, tap predelay.
    • +
  • Class candidate: TapReflections.
    • +
+ + + +
Control GroupParameters
CloudSeedTapTAP_ENABLED_PARAM, TAP_COUNT_PARAM, TAP_DECAY_PARAM, TAP_PREDELAY_PARAM, TAP_LENGTH_PARAM
+
+ +
+ Early Diffusion +
    +
  • Primitives: cascaded allpass diffusers, local feedback, modulated delay offsets.
    • +
  • Modulators: LFO or low-rate random walk.
    • +
  • Class candidate: EarlyDiffuser.
    • +
+ + + +
Control GroupParameters
CloudSeedEarlyDiffusionEARLY_DIFFUSE_ENABLED_PARAM, EARLY_DIFFUSE_COUNT_PARAM, EARLY_DIFFUSE_DELAY_PARAM, EARLY_DIFFUSE_MOD_AMOUNT_PARAM, EARLY_DIFFUSE_FEEDBACK_PARAM, EARLY_DIFFUSE_MOD_RATE_PARAM
+
+ +
+ Late Reverb Core +
    +
  • Primitives: delay-bank, feedback matrix (Hadamard/Householder style), per-line damping, decay, modulation.
    • +
  • Optional tail post-diffusion sub-stage for density control.
    • +
  • Class candidate: LateReverbCore.
    • +
+ + + +
Control GroupParameters
CloudSeedLateReverbLATE_MODE_PARAM, LATE_LINE_COUNT_PARAM, LATE_DIFFUSE_ENABLED_PARAM, LATE_DIFFUSE_COUNT_PARAM, LATE_LINE_SIZE_PARAM, LATE_LINE_MOD_AMOUNT_PARAM, LATE_DIFFUSE_DELAY_PARAM, LATE_DIFFUSE_MOD_AMOUNT_PARAM, LATE_LINE_DECAY_PARAM, LATE_LINE_MOD_RATE_PARAM, LATE_DIFFUSE_FEEDBACK_PARAM, LATE_DIFFUSE_MOD_RATE_PARAM
+
+ +
+ Output EQ / Spectral Shaping +
    +
  • Primitives: low shelf, high shelf, low-pass post-filter.
    • +
  • Class candidate: OutputEq.
    • +
+ + + +
Control GroupParameters
CloudSeedEqEQ_LOW_SHELF_ENABLED_PARAM, EQ_HIGH_SHELF_ENABLED_PARAM, EQ_LOWPASS_ENABLED_PARAM, EQ_LOW_FREQ_PARAM, EQ_HIGH_FREQ_PARAM, EQ_CUTOFF_PARAM, EQ_LOW_GAIN_PARAM, EQ_HIGH_GAIN_PARAM, EQ_CROSS_SEED_PARAM
+
+ +
+ Dry/Early/Late Mix + Output +
    +
  • Primitives: gain VCAs, summing mixer, output safety limiter (optional).
    • +
  • Class candidate: OutputMixer.
    • +
+ + + +
Control GroupParameters
CloudSeedGlobalDRY_OUT_PARAM, EARLY_OUT_PARAM, LATE_OUT_PARAM
+
+ +
+ Seed / Randomization Layer +
    +
  • Primitives: deterministic RNG, parameter jitter constraints, per-stage seed dispatch.
    • +
  • Class candidate: SeedRouter.
    • +
+ + + +
Control GroupParameters
CloudSeedSeedsSEED_TAP_PARAM, SEED_DIFFUSION_PARAM, SEED_DELAY_PARAM, SEED_POST_DIFFUSION_PARAM
+
+ +
+ Daisy 8-Knob Performance Layer + + + + + + + + + + +
Performance ParamSuggested Macro Mapping
MIX_PARAMINPUT_MIX_PARAM + global wet/dry mix logic
SIZE_PARAMLATE_LINE_SIZE_PARAM
DECAY_PARAMLATE_LINE_DECAY_PARAM
DIFFUSION_PARAMEARLY_DIFFUSE_FEEDBACK_PARAM + LATE_DIFFUSE_FEEDBACK_PARAM
PRE_DELAY_PARAMTAP_PREDELAY_PARAM
DAMPING_PARAMHIGH_CUT_PARAM + per-line damping
MODULATION_PARAMLATE_LINE_MOD_AMOUNT_PARAM + EARLY_DIFFUSE_MOD_AMOUNT_PARAM
MODULATION_RATE_PARAMLATE_LINE_MOD_RATE_PARAM + EARLY_DIFFUSE_MOD_RATE_PARAM
+
+
+
+
+ + + + diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_BLOCK_DIAGRAM.md b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_BLOCK_DIAGRAM.md new file mode 100644 index 000000000..1a5a82d85 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_BLOCK_DIAGRAM.md @@ -0,0 +1,306 @@ +# CloudSeedCore Interactive DSP Block Diagram (Daisy Bridge) + +This schematic describes an interactive CloudSeedCore-style reverb architecture for Daisy Seed/Field integration. + +- Shows **audio signal flow** from input to output. +- Breaks down the engine into main FX stages. +- Expands each stage into DSP primitives/classes. +- Documents control/parameter ownership by block. + +--- + +## 1) Top-Level Signal Flow + +```mermaid +flowchart LR + IN_L[Input L] --> INMIX + IN_R[Input R] --> INMIX + + subgraph PRE[Input + Preconditioning] + INMIX[InputMix] + HPF[LowCut / HPF] + LPF[HighCut / LPF] + INMIX --> HPF --> LPF + end + + LPF --> TAPS + LPF --> EARLY + + subgraph EARLY_PATH[Early Reflection Path] + TAPS[Multitap Reflections] + EARLYDIFF[Early Diffusion Network] + TAPS --> EARLYDIFF + end + + EARLYDIFF --> LATE + + subgraph LATE_PATH[Late Reverb Path] + LATE[Late FDN / Delay Matrix] + POSTDIFF[Post/Late Diffusion] + MOD[Modulation Layer] + LATE --> POSTDIFF --> MOD + end + + MOD --> EQ + + subgraph TONE[Output EQ / Spectral Shaping] + EQ[Low Shelf + High Shelf + Lowpass] + end + + EQ --> WETMIX + + subgraph MIXOUT[Mix / Routing] + DRY[DryOut Gain] + EOUT[EarlyOut Gain] + LOUT[LateOut Gain] + WETMIX[Wet Bus] + SUM[Output Summing] + WETMIX --> EOUT --> SUM + WETMIX --> LOUT --> SUM + INMIX --> DRY --> SUM + end + + SUM --> OUT_L[Output L] + SUM --> OUT_R[Output R] +``` + +--- + +## 2) Interactive Control Plane (Parameter Domains) + +```mermaid +flowchart TB + UI[Hardware UI: Seed / Field / MIDI] --> CM[ControlModel 0..1 normalized] + CM --> PERF[CloudSeedPerformance] + + PERF --> G[CloudSeedGlobal] + PERF --> T[CloudSeedTap] + PERF --> ED[CloudSeedEarlyDiffusion] + PERF --> LR[CloudSeedLateReverb] + PERF --> EQ[CloudSeedEq] + PERF --> S[CloudSeedSeeds] + + G --> DSP[CloudSeed DSP Engine] + T --> DSP + ED --> DSP + LR --> DSP + EQ --> DSP + S --> DSP +``` + +--- + +## 3) Expandable DSP Primitives by Main FX Block + +## 3.1 Input + Preconditioning (Global) + +```mermaid +flowchart LR + X[Input stereo/mono] --> MIX[InputMix] + MIX --> HP[HPF one-pole/bq] + HP --> LP[LPF one-pole/bq] + LP --> Y[Conditioned input] +``` + +**DSP primitives/classes** +- Gain stage (`InputMix`). +- High-pass filter (`LowCutEnabled`, `LowCut`). +- Low-pass filter (`HighCutEnabled`, `HighCut`). + +**Controls (CloudSeedGlobal)** +- `INTERPOLATION_PARAM` +- `INPUT_MIX_PARAM` +- `LOW_CUT_ENABLED_PARAM`, `LOW_CUT_PARAM` +- `HIGH_CUT_ENABLED_PARAM`, `HIGH_CUT_PARAM` +- `DRY_OUT_PARAM`, `EARLY_OUT_PARAM`, `LATE_OUT_PARAM` + +--- + +## 3.2 Multitap Reflections (Tap Block) + +```mermaid +flowchart LR + X[Conditioned input] --> TD[Tap delay lines] + TD --> TG[Tap gain envelope / decay law] + TG --> TSUM[Tap sum] +``` + +**DSP primitives/classes** +- Parallel short delay lines. +- Per-tap gain/decay scaling. +- Optional tap predelay. + +**Controls (CloudSeedTap)** +- `TAP_ENABLED_PARAM` +- `TAP_COUNT_PARAM` +- `TAP_DECAY_PARAM` +- `TAP_PREDELAY_PARAM` +- `TAP_LENGTH_PARAM` + +--- + +## 3.3 Early Diffusion Network + +```mermaid +flowchart LR + X[Tap sum / direct feed] --> AP1[Allpass stage 1] + AP1 --> AP2[Allpass stage 2] + AP2 --> AP3[Allpass stage N] + AP3 --> FB[Feedback mix] + FB --> OUT[Early diffuse out] + MOD[Slow delay modulation] --> AP1 + MOD --> AP2 + MOD --> AP3 +``` + +**DSP primitives/classes** +- Cascaded allpass diffusers. +- Diffusion feedback path. +- Delay-time modulation (LFO/random). + +**Controls (CloudSeedEarlyDiffusion)** +- `EARLY_DIFFUSE_ENABLED_PARAM` +- `EARLY_DIFFUSE_COUNT_PARAM` +- `EARLY_DIFFUSE_DELAY_PARAM` +- `EARLY_DIFFUSE_MOD_AMOUNT_PARAM` +- `EARLY_DIFFUSE_FEEDBACK_PARAM` +- `EARLY_DIFFUSE_MOD_RATE_PARAM` + +--- + +## 3.4 Late Reverb Core (FDN / Delay Matrix) + +```mermaid +flowchart LR + IN[Early diffuse in] --> DL1[Delay line 1] + IN --> DL2[Delay line 2] + IN --> DLN[Delay line N] + + DL1 --> MX[Feedback matrix / Householder / Hadamard] + DL2 --> MX + DLN --> MX + + MX --> DAMP[Damping filters per line] + DAMP --> MOD[Line modulation] + MOD --> DEC[Per-line decay gains] + DEC --> OUT[Late tail bus] + + OUT --> FBRET[Feedback return] + FBRET --> DL1 + FBRET --> DL2 + FBRET --> DLN +``` + +**DSP primitives/classes** +- Delay-bank (`LateLineCount`, `LateLineSize`). +- Feedback mixing matrix (`LateMode`). +- Per-line damping filters. +- Delay-line modulation (`LateLineModAmount`, `LateLineModRate`). +- Decay gains (`LateLineDecay`). +- Optional late diffusion chain. + +**Controls (CloudSeedLateReverb)** +- `LATE_MODE_PARAM` +- `LATE_LINE_COUNT_PARAM` +- `LATE_DIFFUSE_ENABLED_PARAM` +- `LATE_DIFFUSE_COUNT_PARAM` +- `LATE_LINE_SIZE_PARAM` +- `LATE_LINE_MOD_AMOUNT_PARAM` +- `LATE_DIFFUSE_DELAY_PARAM` +- `LATE_DIFFUSE_MOD_AMOUNT_PARAM` +- `LATE_LINE_DECAY_PARAM` +- `LATE_LINE_MOD_RATE_PARAM` +- `LATE_DIFFUSE_FEEDBACK_PARAM` +- `LATE_DIFFUSE_MOD_RATE_PARAM` + +--- + +## 3.5 Output EQ / Spectral Section + +```mermaid +flowchart LR + X[Wet tail] --> LS[Low shelf] + LS --> HS[High shelf] + HS --> LP[Lowpass] + LP --> Y[EQ out] +``` + +**DSP primitives/classes** +- Shelving filters. +- Final low-pass roll-off. +- Cross-seed logic for parameter randomization coupling. + +**Controls (CloudSeedEq)** +- `EQ_LOW_SHELF_ENABLED_PARAM` +- `EQ_HIGH_SHELF_ENABLED_PARAM` +- `EQ_LOWPASS_ENABLED_PARAM` +- `EQ_LOW_FREQ_PARAM` +- `EQ_HIGH_FREQ_PARAM` +- `EQ_CUTOFF_PARAM` +- `EQ_LOW_GAIN_PARAM` +- `EQ_HIGH_GAIN_PARAM` +- `EQ_CROSS_SEED_PARAM` + +--- + +## 3.6 Seed/Randomization Control Layer + +```mermaid +flowchart LR + TRIG[Randomize trigger] --> RNG[Seed generator] + RNG --> ST[SeedTap] + RNG --> SDIF[SeedDiffusion] + RNG --> SDL[SeedDelay] + RNG --> SPD[SeedPostDiffusion] + + ST --> TAPCFG[Tap config] + SDIF --> EDCFG[Early diffusion config] + SDL --> LCFG[Late delay config] + SPD --> PDCFG[Post diffusion config] +``` + +**DSP primitives/classes** +- Deterministic seedable RNG. +- Block-local seed routing (tap/diffusion/delay/post-diffusion). + +**Controls (CloudSeedSeeds)** +- `SEED_TAP_PARAM` +- `SEED_DIFFUSION_PARAM` +- `SEED_DELAY_PARAM` +- `SEED_POST_DIFFUSION_PARAM` + +--- + +## 4) Daisy Performance Macro Mapping (Current 8 Knobs) + +| Performance Param | Suggested CloudSeed Domain | +|---|---| +| `MIX_PARAM` | `INPUT_MIX_PARAM` / wet blend macro | +| `SIZE_PARAM` | `LATE_LINE_SIZE_PARAM` | +| `DECAY_PARAM` | `LATE_LINE_DECAY_PARAM` | +| `DIFFUSION_PARAM` | `EARLY_DIFFUSE_FEEDBACK_PARAM` + `LATE_DIFFUSE_FEEDBACK_PARAM` macro | +| `PRE_DELAY_PARAM` | `TAP_PREDELAY_PARAM` | +| `DAMPING_PARAM` | `HIGH_CUT_PARAM` + damping filters macro | +| `MODULATION_PARAM` | `LATE_LINE_MOD_AMOUNT_PARAM` + `EARLY_DIFFUSE_MOD_AMOUNT_PARAM` | +| `MODULATION_RATE_PARAM` | `LATE_LINE_MOD_RATE_PARAM` + `EARLY_DIFFUSE_MOD_RATE_PARAM` | + +--- + +## 5) Practical Class/Module Decomposition (for implementation) + +- `InputConditioner` + - Gain + HP/LP filters. +- `TapReflections` + - Multitap delays and decay curves. +- `EarlyDiffuser` + - Cascaded allpass network + modulation. +- `LateReverbCore` + - Delay-bank, feedback matrix, damping, modulation, decay. +- `OutputEq` + - Shelf + lowpass chain. +- `SeedRouter` + - Seeded randomization and per-block dispatch. +- `CloudSeedEngineAdapter` + - Bridges `ControlModel` / per-class enums to DSP internals. + +This decomposition aligns with the enum classes in `CloudSeedInteractiveParameters.h` and keeps Seed/Field control mapping independent from DSP internals. diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_PARAMETER_BREAKDOWN_BKS.md b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_PARAMETER_BREAKDOWN_BKS.md new file mode 100644 index 000000000..8ea009a87 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CLOUDSEED_PARAMETER_BREAKDOWN_BKS.md @@ -0,0 +1,75 @@ +# CloudSeed Parameter Breakdown (BKS `Parameter2`) + +This breakdown is taken from: + +- `Software/GuitarPedal/dependencies/CloudSeed/Parameter.h` +- Repo: `bkshepherd/DaisySeedProjects` + +The source enum is `Parameter2`. In this bridge, it is grouped into per-class interactive domains: + +- `CloudSeedGlobal` +- `CloudSeedTap` +- `CloudSeedEarlyDiffusion` +- `CloudSeedLateReverb` +- `CloudSeedEq` +- `CloudSeedSeeds` + +## Grouping used in `CloudSeedInteractiveParameters.h` + +### CloudSeedGlobal +- `INPUT_MIX_PARAM` +- `PRE_DELAY_PARAM` +- `HIGH_PASS_PARAM` +- `LOW_PASS_PARAM` +- `DRY_OUT_PARAM` +- `PREDELAY_OUT_PARAM` +- `EARLY_OUT_PARAM` +- `MAIN_OUT_PARAM` +- `HIGH_PASS_ENABLED_PARAM` +- `LOW_PASS_ENABLED_PARAM` +- `INTERPOLATION_PARAM` + +### CloudSeedTap +- `TAP_COUNT_PARAM` +- `TAP_LENGTH_PARAM` +- `TAP_GAIN_PARAM` +- `TAP_DECAY_PARAM` + +### CloudSeedEarlyDiffusion +- `DIFFUSION_ENABLED_PARAM` +- `DIFFUSION_STAGES_PARAM` +- `DIFFUSION_DELAY_PARAM` +- `DIFFUSION_FEEDBACK_PARAM` +- `EARLY_DIFFUSION_MOD_AMOUNT_PARAM` +- `EARLY_DIFFUSION_MOD_RATE_PARAM` + +### CloudSeedLateReverb +- `LINE_COUNT_PARAM` +- `LINE_DELAY_PARAM` +- `LINE_DECAY_PARAM` +- `LATE_DIFFUSION_ENABLED_PARAM` +- `LATE_DIFFUSION_STAGES_PARAM` +- `LATE_DIFFUSION_DELAY_PARAM` +- `LATE_DIFFUSION_FEEDBACK_PARAM` +- `LINE_MOD_AMOUNT_PARAM` +- `LINE_MOD_RATE_PARAM` +- `LATE_DIFFUSION_MOD_AMOUNT_PARAM` +- `LATE_DIFFUSION_MOD_RATE_PARAM` +- `LATE_STAGE_TAP_PARAM` + +### CloudSeedEq +- `POST_LOWSHELF_GAIN_PARAM` +- `POST_LOWSHELF_FREQUENCY_PARAM` +- `POST_HIGHSHELF_GAIN_PARAM` +- `POST_HIGHSHELF_FREQUENCY_PARAM` +- `POST_CUTOFF_FREQUENCY_PARAM` +- `LOWSHELF_ENABLED_PARAM` +- `HIGHSHELF_ENABLED_PARAM` +- `CUTOFF_ENABLED_PARAM` + +### CloudSeedSeeds +- `TAP_SEED_PARAM` +- `DIFFUSION_SEED_PARAM` +- `DELAY_SEED_PARAM` +- `POST_DIFFUSION_SEED_PARAM` +- `CROSS_SEED_PARAM` diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/CloudSeedControlModel.h b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CloudSeedControlModel.h new file mode 100644 index 000000000..8e7dbbbfc --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CloudSeedControlModel.h @@ -0,0 +1,37 @@ +#pragma once + +#include + +namespace cloudseedbridge +{ +/** + * Control-independent parameter model. + * + * Any hardware mapping (Seed ADC, Field knobs, MIDI CC, etc.) writes to this + * normalized [0..1] domain. DSP/engine mapping consumes this model. + */ +struct ControlModel +{ + float mix = 0.5f; + float size = 0.55f; + float decay = 0.65f; + float diffusion = 0.60f; + float pre_delay = 0.05f; + float damping = 0.45f; + float modulation = 0.30f; + float modulationrate = 0.25f; + + void Clamp() + { + mix = std::clamp(mix, 0.0f, 1.0f); + size = std::clamp(size, 0.0f, 1.0f); + decay = std::clamp(decay, 0.0f, 1.0f); + diffusion = std::clamp(diffusion, 0.0f, 1.0f); + pre_delay = std::clamp(pre_delay, 0.0f, 1.0f); + damping = std::clamp(damping, 0.0f, 1.0f); + modulation = std::clamp(modulation, 0.0f, 1.0f); + modulationrate = std::clamp(modulationrate, 0.0f, 1.0f); + } +}; + +} // namespace cloudseedbridge diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/CloudSeedInteractiveParameters.h b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CloudSeedInteractiveParameters.h new file mode 100644 index 000000000..837414303 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/CloudSeedInteractiveParameters.h @@ -0,0 +1,277 @@ +#pragma once + +namespace cloudseedbridge +{ +/** + * BKS CloudSeed parameter breakdown. + * + * Derived from: + * https://github.com/bkshepherd/DaisySeedProjects/ + * tree/main/Software/GuitarPedal/dependencies/CloudSeed/Parameter.h + * + * Source enum in that project is `Parameter2`. + * This file organizes those parameters into Rack-style per-block classes. + */ + +struct CloudSeedGlobal +{ + enum ParamIds + { + INPUT_MIX_PARAM, + PRE_DELAY_PARAM, + HIGH_PASS_PARAM, + LOW_PASS_PARAM, + DRY_OUT_PARAM, + PREDELAY_OUT_PARAM, + EARLY_OUT_PARAM, + MAIN_OUT_PARAM, + HIGH_PASS_ENABLED_PARAM, + LOW_PASS_ENABLED_PARAM, + INTERPOLATION_PARAM, + NUM_PARAMS + }; + + enum InputIds + { + GLOBAL_CV_INPUT, + INPUT_MIX_CV_INPUT, + PRE_DELAY_CV_INPUT, + FILTER_CV_INPUT, + NUM_INPUTS + }; + + enum OutputIds + { + DRY_OUTPUT, + PREDELAY_OUTPUT, + EARLY_OUTPUT, + MAIN_OUTPUT, + NUM_OUTPUTS + }; + + enum LightIds + { + INTERPOLATION_LIGHT, + FILTERS_ENABLED_LIGHT, + NUM_LIGHTS + }; +}; + +struct CloudSeedTap +{ + enum ParamIds + { + TAP_COUNT_PARAM, + TAP_LENGTH_PARAM, + TAP_GAIN_PARAM, + TAP_DECAY_PARAM, + NUM_PARAMS + }; + + enum InputIds + { + TAP_COUNT_CV_INPUT, + TAP_LENGTH_CV_INPUT, + TAP_GAIN_CV_INPUT, + TAP_DECAY_CV_INPUT, + NUM_INPUTS + }; + + enum OutputIds + { + TAP_DEBUG_OUTPUT, + NUM_OUTPUTS + }; + + enum LightIds + { + TAP_ACTIVE_LIGHT, + NUM_LIGHTS + }; +}; + +struct CloudSeedEarlyDiffusion +{ + enum ParamIds + { + DIFFUSION_ENABLED_PARAM, + DIFFUSION_STAGES_PARAM, + DIFFUSION_DELAY_PARAM, + DIFFUSION_FEEDBACK_PARAM, + EARLY_DIFFUSION_MOD_AMOUNT_PARAM, + EARLY_DIFFUSION_MOD_RATE_PARAM, + NUM_PARAMS + }; + + enum InputIds + { + EARLY_DIFFUSION_AMOUNT_INPUT, + EARLY_DIFFUSION_TIME_INPUT, + EARLY_DIFFUSION_MOD_INPUT, + NUM_INPUTS + }; + + enum OutputIds + { + EARLY_DIFFUSION_DEBUG_OUTPUT, + NUM_OUTPUTS + }; + + enum LightIds + { + EARLY_DIFFUSION_ENABLED_LIGHT, + NUM_LIGHTS + }; +}; + +struct CloudSeedLateReverb +{ + enum ParamIds + { + LINE_COUNT_PARAM, + LINE_DELAY_PARAM, + LINE_DECAY_PARAM, + LATE_DIFFUSION_ENABLED_PARAM, + LATE_DIFFUSION_STAGES_PARAM, + LATE_DIFFUSION_DELAY_PARAM, + LATE_DIFFUSION_FEEDBACK_PARAM, + LINE_MOD_AMOUNT_PARAM, + LINE_MOD_RATE_PARAM, + LATE_DIFFUSION_MOD_AMOUNT_PARAM, + LATE_DIFFUSION_MOD_RATE_PARAM, + LATE_STAGE_TAP_PARAM, + NUM_PARAMS + }; + + enum InputIds + { + SIZE_INPUT, + DECAY_INPUT, + DIFFUSION_INPUT, + MOD_INPUT, + NUM_INPUTS + }; + + enum OutputIds + { + WET_OUTPUT, + NUM_OUTPUTS + }; + + enum LightIds + { + LATE_DIFFUSION_ENABLED_LIGHT, + LATE_STAGE_TAP_LIGHT, + NUM_LIGHTS + }; +}; + +struct CloudSeedEq +{ + enum ParamIds + { + POST_LOWSHELF_GAIN_PARAM, + POST_LOWSHELF_FREQUENCY_PARAM, + POST_HIGHSHELF_GAIN_PARAM, + POST_HIGHSHELF_FREQUENCY_PARAM, + POST_CUTOFF_FREQUENCY_PARAM, + LOWSHELF_ENABLED_PARAM, + HIGHSHELF_ENABLED_PARAM, + CUTOFF_ENABLED_PARAM, + NUM_PARAMS + }; + + enum InputIds + { + EQ_TILT_INPUT, + EQ_FREQ_INPUT, + NUM_INPUTS + }; + + enum OutputIds + { + EQ_DEBUG_OUTPUT, + NUM_OUTPUTS + }; + + enum LightIds + { + EQ_ENABLED_LIGHT, + NUM_LIGHTS + }; +}; + +struct CloudSeedSeeds +{ + enum ParamIds + { + TAP_SEED_PARAM, + DIFFUSION_SEED_PARAM, + DELAY_SEED_PARAM, + POST_DIFFUSION_SEED_PARAM, + CROSS_SEED_PARAM, + NUM_PARAMS + }; + + enum InputIds + { + RANDOMIZE_TRIGGER_INPUT, + SEED_SPREAD_INPUT, + NUM_INPUTS + }; + + enum OutputIds + { + SEED_STATE_OUTPUT, + NUM_OUTPUTS + }; + + enum LightIds + { + RANDOMIZE_LIGHT, + NUM_LIGHTS + }; +}; + +/** + * Performance layer used by the current Daisy Seed 8-knob prototype. + * These are macro controls mapped onto the Parameter2 groups above. + */ +struct CloudSeedPerformance +{ + enum ParamIds + { + MIX_PARAM, + SIZE_PARAM, + DECAY_PARAM, + DIFFUSION_PARAM, + PRE_DELAY_PARAM, + DAMPING_PARAM, + MODULATION_PARAM, + MODULATION_RATE_PARAM, + NUM_PARAMS + }; + + enum InputIds + { + AUDIO_L_INPUT, + AUDIO_R_INPUT, + NUM_INPUTS + }; + + enum OutputIds + { + AUDIO_L_OUTPUT, + AUDIO_R_OUTPUT, + NUM_OUTPUTS + }; + + enum LightIds + { + CLIP_LIGHT, + ACTIVE_LIGHT, + NUM_LIGHTS + }; +}; + +} // namespace cloudseedbridge diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/HardwareMapping.h b/MyProjects/_projects/Seed_CloudSeedCoreBridge/HardwareMapping.h new file mode 100644 index 000000000..47ff44fdf --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/HardwareMapping.h @@ -0,0 +1,59 @@ +#pragma once + +#include "CloudSeedControlModel.h" +#include "CloudSeedInteractiveParameters.h" + +#include "daisy_seed.h" + +namespace cloudseedbridge +{ +/** + * Daisy Seed hardware adapter. + * + * Wiring assumption (adjust to your panel): + * A0 mix, A1 size, A2 decay, A3 diffusion, + * A4 pre-delay, A5 damping, A6 modulation amount, A7 modulation rate. + */ +class SeedMapping +{ + public: + void Init(daisy::DaisySeed &seed) + { + daisy::AdcChannelConfig adc_cfg[8]; + for(size_t i = 0; i < 8; ++i) + adc_cfg[i].InitSingle(seed.GetPin(static_cast(15 + i))); + seed.adc.Init(adc_cfg, 8); + seed.adc.Start(); + } + + void ReadInto(daisy::DaisySeed &seed, ControlModel &controls) + { + controls.mix = seed.adc.GetFloat(CloudSeedPerformance::MIX_PARAM); + controls.size = seed.adc.GetFloat(CloudSeedPerformance::SIZE_PARAM); + controls.decay = seed.adc.GetFloat(CloudSeedPerformance::DECAY_PARAM); + controls.diffusion + = seed.adc.GetFloat(CloudSeedPerformance::DIFFUSION_PARAM); + controls.pre_delay + = seed.adc.GetFloat(CloudSeedPerformance::PRE_DELAY_PARAM); + controls.damping + = seed.adc.GetFloat(CloudSeedPerformance::DAMPING_PARAM); + controls.modulation + = seed.adc.GetFloat(CloudSeedPerformance::MODULATION_PARAM); + controls.modulationrate + = seed.adc.GetFloat(CloudSeedPerformance::MODULATION_RATE_PARAM); + controls.Clamp(); + } +}; + +/** + * Daisy Field mapping helper for future deployment. + * Not compiled by this Seed example, but keeps controls independent now. + */ +struct FieldMappingLayout +{ + // Field knob plan: + // K1 mix, K2 size, K3 decay, K4 diffusion, + // K5 pre-delay, K6 damping, K7 modulation, K8 modulation-rate. +}; + +} // namespace cloudseedbridge diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/Makefile b/MyProjects/_projects/Seed_CloudSeedCoreBridge/Makefile new file mode 100644 index 000000000..87ea22f99 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/Makefile @@ -0,0 +1,16 @@ +# Project Name +TARGET = Seed_CloudSeedCoreBridge + +# Sources +CPP_SOURCES = Seed_CloudSeedCoreBridge.cpp + +# Use fallback engine by default. Set to 1 after CloudSeedCore import is wired. +CPPFLAGS += -DUSE_CLOUDSEEDCORE=0 + +# Library Locations +LIBDAISY_DIR = ../../../libDaisy +DAISYSP_DIR = ../../../DaisySP + +# Core location, and generic makefile. +SYSTEM_FILES_DIR = $(LIBDAISY_DIR)/core +include $(SYSTEM_FILES_DIR)/Makefile diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/README.md b/MyProjects/_projects/Seed_CloudSeedCoreBridge/README.md new file mode 100644 index 000000000..27a9b1d89 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/README.md @@ -0,0 +1,80 @@ +# Seed_CloudSeedCoreBridge + +Bridge project to prepare **CloudSeedCore** for Daisy hardware in a **controls-independent** way. + +## What is included + +- A normalized `ControlModel` (`0..1`) that is hardware agnostic. +- A Daisy Seed ADC mapping layer that writes into `ControlModel`. +- A Field mapping plan (`FieldMappingLayout`) so the same model can be reused on Daisy Field. +- A fallback DSP adapter (`ReverbSc`) so the project compiles and runs even before CloudSeedCore is linked. +- Rack-style per-class interactive enums (`ParamIds`, `InputIds`, `OutputIds`, `LightIds`) in `CloudSeedInteractiveParameters.h`. + +## Why this structure + +CloudSeedCore integration can be done once in an engine adapter, while each hardware target only needs a mapping layer. + +``` +Hardware (Seed/Field/MIDI) + -> ControlModel (normalized) + -> CloudSeed parameter map + -> Audio engine +``` + +## CloudSeedCore import status + +The environment used to produce this change could not reach GitHub (`403` tunnel/connect restriction), so the external repository could not be cloned automatically. + +When network access is available, import CloudSeedCore manually: + +```bash +cd /workspace/DaisyExamples +mkdir -p third_party +git clone https://github.com/GhostNoteAudio/CloudSeedCore third_party/CloudSeedCore +``` + +Then: + +1. Add the CloudSeedCore source files to `CPP_SOURCES` in `Makefile`. +2. Add include paths for `third_party/CloudSeedCore`. +3. Set `CPPFLAGS += -DUSE_CLOUDSEEDCORE=1`. +4. Replace fallback adapter internals with concrete CloudSeedCore calls. + +## Field hardware mapping (planned) + +Recommended Field knob map: + +- K1: Mix +- K2: Size +- K3: Decay +- K4: Diffusion +- K5: Pre-delay +- K6: Damping +- K7: Modulation amount +- K8: Modulation rate + +These directly map to the same `ControlModel` used by Seed. + + +Detailed architecture schematics: see `CLOUDSEED_BLOCK_DIAGRAM.md` (Markdown) and `CLOUDSEED_BLOCK_DIAGRAM.html` (interactive HTML) for signal flow, expandable DSP primitives/classes, and control ownership. + +BKS-based parameter grouping reference: `CLOUDSEED_PARAMETER_BREAKDOWN_BKS.md` (derived from `bkshepherd/DaisySeedProjects` `Parameter2`). + +## Interactive parameter organization + +Interactive parameters are now organized per class (similar to your Plaits-style enum layout): + +- `CloudSeedGlobal` +- `CloudSeedTap` +- `CloudSeedEarlyDiffusion` +- `CloudSeedLateReverb` +- `CloudSeedEq` +- `CloudSeedSeeds` +- `CloudSeedPerformance` (8-knob Seed panel) + +Each class exposes: + +- `enum ParamIds` +- `enum InputIds` +- `enum OutputIds` +- `enum LightIds` diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/Seed_CloudSeedCoreBridge.cpp b/MyProjects/_projects/Seed_CloudSeedCoreBridge/Seed_CloudSeedCoreBridge.cpp new file mode 100644 index 000000000..9064bb014 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/Seed_CloudSeedCoreBridge.cpp @@ -0,0 +1,94 @@ +#include "HardwareMapping.h" + +#include "daisy_seed.h" +#include "daisysp.h" + +using namespace daisy; +using namespace daisysp; +using namespace cloudseedbridge; + +DaisySeed seed; +ControlModel controls; +SeedMapping seed_mapping; + +/** + * If CloudSeedCore source is imported under third_party/CloudSeedCore and wired + * into the Makefile, define USE_CLOUDSEEDCORE=1 to use the real engine. + * Otherwise we run a ReverbSc fallback so the project still builds/tests. + */ +#if USE_CLOUDSEEDCORE +// TODO: add concrete CloudSeedCore includes and parameter forwarding here. +#endif + +class ReverbEngineAdapter +{ + public: + void Init(float sample_rate) + { + reverb_.Init(sample_rate); + reverb_.SetFeedback(0.84f); + reverb_.SetLpFreq(12000.0f); + } + + void SetControlModel(const ControlModel &m) + { + // Approximate semantic mapping for fallback engine. + mix_ = m.mix; + feedback_ = 0.40f + (m.decay * 0.58f); + lp_hz_ = 1500.0f + (1.0f - m.damping) * 17000.0f; + reverb_.SetFeedback(feedback_); + reverb_.SetLpFreq(lp_hz_); + } + + inline float Process(float in) + { + float wet_l = 0.0f; + float wet_r = 0.0f; + reverb_.Process(in, in, &wet_l, &wet_r); + const float wet = 0.5f * (wet_l + wet_r); + return (in * (1.0f - mix_)) + (wet * mix_); + } + + private: + ReverbSc reverb_; + float mix_ = 0.5f; + float feedback_ = 0.84f; + float lp_hz_ = 12000.0f; +}; + +ReverbEngineAdapter engine; + +void AudioCallback(AudioHandle::InputBuffer in, + AudioHandle::OutputBuffer out, + size_t size) +{ + seed.ProcessAllControls(); + seed_mapping.ReadInto(seed, controls); + engine.SetControlModel(controls); + + for(size_t i = 0; i < size; i++) + { + float mono = 0.5f * (in[0][i] + in[1][i]); + float y = engine.Process(mono); + out[0][i] = y; + out[1][i] = y; + } +} + +int main(void) +{ + seed.Configure(); + seed.Init(); + seed.SetAudioBlockSize(48); + + seed_mapping.Init(seed); + + engine.Init(seed.AudioSampleRate()); + + seed.StartAudio(AudioCallback); + + while(true) + { + System::Delay(10); + } +} diff --git a/MyProjects/_projects/Seed_CloudSeedCoreBridge/import_cloudseedcore.sh b/MyProjects/_projects/Seed_CloudSeedCoreBridge/import_cloudseedcore.sh new file mode 100755 index 000000000..9c0f7c831 --- /dev/null +++ b/MyProjects/_projects/Seed_CloudSeedCoreBridge/import_cloudseedcore.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash +set -euo pipefail + +ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)" +DEST_DIR="${ROOT_DIR}/third_party/CloudSeedCore" + +mkdir -p "${ROOT_DIR}/third_party" + +if [[ -d "${DEST_DIR}/.git" ]]; then + echo "CloudSeedCore already present at ${DEST_DIR}" + exit 0 +fi + +echo "Cloning CloudSeedCore into ${DEST_DIR} ..." +git clone https://github.com/GhostNoteAudio/CloudSeedCore "${DEST_DIR}" + +echo "Done. Next: wire source files into MyProjects/_projects/Seed_CloudSeedCoreBridge/Makefile"