main.cpp

#include "IEngine.h"
#include "ModeFM.h"
#include "ModeString.h"
#include "ModeSwarm.h"
#include "ModeWavetable.h"
#include "daisy_legio.h"
#include "daisysp.h"
#include <new>

using namespace daisy;
using namespace daisysp;

DaisyLegio hw;

// Engines
ModeWavetable engine_wt;
ModeFM engine_fm;
ModeSwarm engine_swarm;
ModeString engine_string;
IEngine *engines[] = {&engine_wt, &engine_fm, &engine_swarm, &engine_string};

enum FxEngine { ENG_WT, ENG_FM, ENG_SWARM, ENG_STRING };
FxEngine current_engine = ENG_WT;

enum UiState { UI_NORMAL, UI_SECONDARY, UI_ENVELOPE };
UiState ui_state = UI_NORMAL;

// Timings
uint32_t encoder_press_start = 0;
static constexpr uint32_t kLongPressSecondary = 2000; // 2 seconds
static constexpr uint32_t kLongPressEnvelope = 4000;  // 4 seconds

// Envelope ADR Parameters
float env_attack = 0.01f;
float env_decay = 0.5f;
float env_release = 0.5f;
Adsr envelope;

// Soft Knobs for Envelope to prevent jumps
IEngine::SoftKnob env_knob_decay;
IEngine::SoftKnob env_knob_release;

// 1V/Oct and Gate
float current_pitch = 440.0f;
float env_out = 0.0f;
bool last_gate_state = false;

// Master Effects
// Master Effects
ReverbSc reverb;
float reverb_send = 0.1f;
float delay_send = 0.0f;

// Stereo Delay Lines in SDRAM (64MB available)
DelayLine<float, 48000> DSY_SDRAM_BSS delay_l;
DelayLine<float, 48000> DSY_SDRAM_BSS delay_r;

// Soft Limiter / Maximizer Helper
float SoftMaximizer(float x) {
  // Cubic Soft Clip suitable for maximizing loudness
  // Pre-gain: Boost input level to drive the limiter
  x *= 2.0f;

  if (x < -1.0f)
    return -0.66f; // Hard limit floor (approx 2/3)
  if (x > 1.0f)
    return 0.66f; // Hard limit ceiling
  return x - (x * x * x) / 3.0f;
}

void AudioCallback(AudioHandle::InputBuffer in, AudioHandle::OutputBuffer out,
                   size_t size) {
  hw.ProcessAnalogControls();

  // 1. INPUTS MAPPING (GLOBAL)
  float pitch_knob = hw.GetKnobValue(DaisyLegio::CONTROL_PITCH);
  float midi_note = 36.0f + (pitch_knob * 60.0f);
  current_pitch = mtof(midi_note);

  // Gate handling
  bool gate_state = hw.Gate();

  if (gate_state && !last_gate_state) {
    envelope.Retrigger(false);
    engine_string.Trigger();
  }
  last_gate_state = gate_state;

  for (int i = 0; i < 4; i++) {
    engines[i]->SetFreq(current_pitch);
  }

  // Get Delay Amount
  float delay_send = engines[current_engine]->GetDelayAmount();

  for (size_t i = 0; i < size; i++) {
    float sig_l = 0.0f, sig_r = 0.0f;
    env_out = envelope.Process(gate_state);

    engines[current_engine]->Process(0, 0, &sig_l, &sig_r);

    sig_l *= env_out;
    sig_r *= env_out;

    // --- REVERB ---
    float rev_l, rev_r;
    reverb.Process(sig_l * reverb_send, sig_r * reverb_send, &rev_l, &rev_r);

    // --- DELAY ---
    float del_out_l = delay_l.Read();
    float del_out_r = delay_r.Read();

    // Feedback Loop (0.4f = 40% Feedback)
    delay_l.Write((sig_l * delay_send) + (del_out_l * 0.4f));
    delay_r.Write((sig_r * delay_send) + (del_out_r * 0.4f));

    // Sum and Apply Soft Limiter (Maximizer)
    float final_l = sig_l + rev_l + del_out_l;
    float final_r = sig_r + rev_r + del_out_r;

    out[0][i] = SoftMaximizer(final_l);
    out[1][i] = SoftMaximizer(final_r);
  }
}

int main(void) {
  hw.Init();
  hw.StartAdc();
  float sample_rate = hw.AudioSampleRate();

  // Init Engines
  for (int i = 0; i < 4; i++) {
    engines[i]->Init(sample_rate);
  }

  // Init Envelope (ADR mode using ADSR with Sustain=0)
  envelope.Init(sample_rate);
  envelope.SetSustainLevel(0.0f);
  env_knob_decay.Init(0.5f);
  env_knob_release.Init(0.5f);

  // Init Effects
  reverb.Init(sample_rate);
  reverb.SetFeedback(0.85f);
  reverb.SetLpFreq(12000.0f);

  // Init Delay
  delay_l.Init();
  delay_r.Init();
  delay_l.SetDelay(24000.0f); // 0.5s Left
  delay_r.SetDelay(36000.0f); // 0.75s Right

  hw.StartAudio(AudioCallback);

  uint32_t led_tick = 0;
  uint32_t encoder_press_start = 0;
  float p1_val = 0.5f;

  const uint32_t kHoldEnvelope = 1000;
  const uint32_t kHoldSecondary = 2500;

  // LED blink state for slow/fast feedback
  bool blink_state = false;

  while (1) {
    hw.ProcessDigitalControls();
    led_tick = System::GetNow();

    // Global Blink Timer (Fast: 100ms, Slow: 500ms approx)
    blink_state = (led_tick / 150) % 2;

    // 1. Encoder Handling (Press)
    if (hw.encoder.Pressed()) {
      if (encoder_press_start == 0) {
        encoder_press_start = led_tick;
      }
      // If holding, we just wait. Feedback is handled in LED section.
    } else {
      // Release Event
      if (encoder_press_start > 0) {
        uint32_t hold_time = led_tick - encoder_press_start;
        encoder_press_start = 0;

        if (hold_time < kHoldEnvelope) {
          // SHORT PRESS: Back to Normal OR Next Engine
          if (ui_state != UI_NORMAL) {
            ui_state = UI_NORMAL;
          } else {
            current_engine = (FxEngine)((current_engine + 1) % 4);
          }
        } else if (hold_time < kHoldSecondary) {
          // MEDIUM PRESS: Envelope Mode
          ui_state = UI_ENVELOPE;
        } else {
          // LONG PRESS: Secondary Mode
          ui_state = UI_SECONDARY;
        }
      }
    }

    // --- CONTROL UPDATE ---
    float k1 = hw.GetKnobValue(DaisyLegio::CONTROL_KNOB_TOP);
    float k2 = hw.GetKnobValue(DaisyLegio::CONTROL_KNOB_BOTTOM);
    int s1 = hw.sw[0].Read();
    int s2 = hw.sw[1].Read();

    // P1 (Encoder): Standard relative increment
    float enc_inc = (float)hw.encoder.Increment() * 0.05f;
    p1_val += enc_inc;
    if (p1_val < 0.0f)
      p1_val = 0.0f;
    if (p1_val > 1.0f)
      p1_val = 1.0f;

    // --- ENGINE / PARAMETER UPDATE ---
    if (ui_state == UI_ENVELOPE) {
      // ENVELOPE MODE: Encoder=Attack, Top=Decay, Bot=Release
      // Use P1 (Accumulated) for Attack
      env_attack = fmap(p1_val, 0.001f, 2.0f, Mapping::LOG);

      float raw_dec = env_knob_decay.Process(k1);
      env_decay = fmap(raw_dec, 0.01f, 5.0f, Mapping::LOG);

      float raw_rel = env_knob_release.Process(k2);
      env_release = fmap(raw_rel, 0.01f, 5.0f, Mapping::LOG);

      envelope.SetAttackTime(env_attack);
      envelope.SetDecayTime(env_decay);
      envelope.SetReleaseTime(env_release);
    } else {
      // Unlatch Envelope Knobs so they are ready when we return
      env_knob_decay.Unlatch();
      env_knob_release.Unlatch();

      // NORMAL OR SECONDARY MODE
      bool is_secondary = (ui_state == UI_SECONDARY);
      // Pass relative increment to Engine for Parameter accumulation
      engines[current_engine]->UpdateControls(enc_inc, k1, k2, s1, s2,
                                              is_secondary);
    }

    // Update Global Reverb AND Delay Send based on Engine State
    reverb_send = engines[current_engine]->GetReverbAmount();
    delay_send = engines[current_engine]->GetDelayAmount();

    // --- LED LOGIC ---
    float r = 0, g = 0, b = 0;

    // Determine Base Color based on Engine
    float er = 0, eg = 0, eb = 0;
    switch (current_engine) {
    case ENG_WT:
      er = 1.0f;
      break; // Red
    case ENG_FM:
      eg = 1.0f;
      break; // Green
    case ENG_SWARM:
      eb = 1.0f;
      break; // Blue
    case ENG_STRING:
      er = eg = eb = 1.0f;
      break; // White
    }

    if (encoder_press_start > 0) {
      // BUTTON HELD FEEDBACK
      uint32_t hold_time = led_tick - encoder_press_start;

      if (hold_time > kHoldSecondary) {
        // Fast Blink Engine Color (Ready for Secondary)
        if ((led_tick % 150) < 75) {
          r = er;
          g = eg;
          b = eb;
        }
      } else if (hold_time > kHoldEnvelope) {
        // Fast Blink Yellow (Ready for Envelope)
        if ((led_tick % 150) < 75) {
          r = 1.0f;
          g = 1.0f;
          b = 0.0f;
        }
      } else {
        // Steady Engine Color (Short Press Range)
        r = er;
        g = eg;
        b = eb;
      }
    } else {
      // STEADY STATE DISPLAY
      if (ui_state == UI_ENVELOPE) {
        // Steady Yellow
        r = 1.0f;
        g = 1.0f;
        b = 0.0f;
      } else if (ui_state == UI_SECONDARY) {
        // Slow Blink Engine Color
        if ((led_tick % 600) < 300) {
          r = er;
          g = eg;
          b = eb;
        }
      } else {
        // Normal: Steady Engine Color
        r = er;
        g = eg;
        b = eb;
      }
    }

    hw.SetLed(DaisyLegio::LED_LEFT, r, g, b);
    hw.SetLed(DaisyLegio::LED_RIGHT, r, g, b);
    hw.UpdateLeds();
    System::Delay(1);
  }
}