monostep/Source/PluginProcessor.h

#pragma once

#include <JuceHeader.h>
#include "dsp/SynthVoice.h"
#include "dsp/StepSequencer.h"
#include "dsp/FxProcessor.h"

class MonostepAudioProcessor final : public juce::AudioProcessor
{
public:
    MonostepAudioProcessor();
    ~MonostepAudioProcessor() override = default;

    void prepareToPlay (double sampleRate, int samplesPerBlock) override;
    void releaseResources() override;
    void processBlock (juce::AudioBuffer<float>&, juce::MidiBuffer&) override;

    juce::AudioProcessorEditor* createEditor() override;
    bool hasEditor() const override { return true; }

    const juce::String getName() const override { return "Monostep"; }
    bool acceptsMidi() const override { return true; }
    bool producesMidi() const override { return false; }
    double getTailLengthSeconds() const override { return 4.0; }

    int getNumPrograms() override { return 1; }
    int getCurrentProgram() override { return 0; }
    void setCurrentProgram (int) override {}
    const juce::String getProgramName (int) override { return {}; }
    void changeProgramName (int, const juce::String&) override {}

    void getStateInformation (juce::MemoryBlock&) override;
    void setStateInformation (const void*, int) override;

    juce::AudioProcessorValueTreeState& getAPVTS() { return apvts; }
    void setZoomIndex (int index) { zoomIndex = juce::jlimit (0, 4, index); }
    int  getZoomIndex() const { return zoomIndex; }
    monostep::StepSequencer& getSequencer() { return sequencer; }
    const monostep::StepSequencer& getSequencer() const { return sequencer; }

    int getNumSteps() const { return monostep::numSteps; }
    int getPatternLength() const { return juce::roundToInt (seqLenParam->load()); }
    int getCurrentStep() const { return playStep.load(); }

    void setStepGate (int idx, bool gate);
    void setStepNote (int idx, int semitone);
    void setStepCents (int idx, float cents);
    void setStepSlide (int idx, bool slide);
    void setStepAccent (int idx, bool accent);
    void shiftPattern (int dir);

    int getNumPresets() const;
    const char* getPresetName (int index) const;
    void applyPreset (int index);
    void randomizePattern();
    void randomizeParams();
    void randomizeOsc();
    void randomizeFilter();
    void randomizeEnv();
    void randomizeSeqSettings();
    void randomizeFx();
    void randomizeAccent();
    void randomizeSlide();
    void randomizeFine();
    void randomizeRate();

    juce::String getStepNoteName (int idx) const;

    std::function<void()> onPatternChanged;

private:
    static juce::AudioProcessorValueTreeState::ParameterLayout createParameterLayout();

    void updateVoiceParams();
    void applyParamValue (const juce::String& id, float value);
    float midiToFreq (float note) const;
    void storeSequence (juce::ValueTree& seq) const;
    void loadSequence (const juce::ValueTree& seq);
    void setDefaultPattern();

    juce::AudioProcessorValueTreeState apvts;

    std::atomic<float>* osc1WaveParam = nullptr;
    std::atomic<float>* osc2WaveParam = nullptr;
    std::atomic<float>* osc1CoarseParam = nullptr;
    std::atomic<float>* osc2CoarseParam = nullptr;
    std::atomic<float>* detuneParam   = nullptr;
    std::atomic<float>* mixParam      = nullptr;
    std::atomic<float>* osc1PhaseParam = nullptr;
    std::atomic<float>* cutoffParam   = nullptr;
    std::atomic<float>* resParam      = nullptr;
    std::atomic<float>* filterTypeParam = nullptr;
    std::atomic<float>* attackParam   = nullptr;
    std::atomic<float>* decayParam    = nullptr;
    std::atomic<float>* sustainParam  = nullptr;
    std::atomic<float>* releaseParam  = nullptr;
    std::atomic<float>* filterAttackParam  = nullptr;
    std::atomic<float>* filterDecayParam   = nullptr;
    std::atomic<float>* filterSustainParam = nullptr;
    std::atomic<float>* filterReleaseParam = nullptr;
    std::atomic<float>* filterEnvAmtParam  = nullptr;
    std::atomic<float>* glideParam    = nullptr;
    std::atomic<float>* masterParam   = nullptr;
    std::atomic<float>* seqLenParam   = nullptr;
    std::atomic<float>* seqRateParam  = nullptr;
    std::atomic<float>* seqRootParam  = nullptr;
    std::atomic<float>* seqOctaveParam = nullptr;
    std::atomic<float>* seqSwingParam  = nullptr;
    std::atomic<float>* seqGateLenParam = nullptr;
    std::atomic<float>* driveParam    = nullptr;
    std::atomic<float>* ringModParam  = nullptr;
    std::atomic<float>* accentParam   = nullptr;
    std::atomic<float>* seqRetrigParam = nullptr;
    std::atomic<float>* delayTimeParam    = nullptr;
    std::atomic<float>* delayStrengthParam = nullptr;
    std::atomic<float>* delaySyncParam   = nullptr;
    std::atomic<float>* delayDryWetParam = nullptr;
    std::atomic<float>* reverbRoomParam  = nullptr;
    std::atomic<float>* reverbStrengthParam = nullptr;
    std::atomic<float>* reverbDiffusionParam = nullptr;
    std::atomic<float>* reverbDryWetParam = nullptr;

    monostep::StepSequencer sequencer;
    monostep::SynthVoice voice;
    monostep::FxProcessor fx;
    juce::AudioBuffer<float> scratch;
    juce::Random random;

    double sampleRate = 44100.0;

    int zoomIndex = 0;

    int lastStep = -1;
    std::atomic<int> playStep { -1 };
    bool lastGateApplied = false;
    float lastFreqApplied = -1.0f;

    bool midiHeld = false;
    int lastMidiNote = -1;

    bool wasPlaying = false;
    double lastHostPpq = -1.0;
    double freePpq = 0.0;
    double retrigPpq = 0.0;
};