Processor.h

/***************************************************************************************************
                 ██████          █████                              █████    █████
                ███░░███        ░░███                              ░░███    ░░███
               ░███ ░░░   █████  ░███████      ██    ██     █████  ███████   ░███ █████
              ███████    ███░░   ░███░░███    ░░    ░░     ███░░  ░░░███░    ░███░░███
             ░░░███░    ░░█████  ░███ ░███                ░░█████   ░███     ░██████░
               ░███      ░░░░███ ░███ ░███                 ░░░░███  ░███ ███ ░███░░███
               █████     ██████  ████ █████    ██    ██    ██████   ░░█████  ████ █████
             ░░░░░     ░░░░░░  ░░░░ ░░░░░    ░░    ░░    ░░░░░░     ░░░░░  ░░░░ ░░░░░
 
            fantastic  spatial  holophonic               synthesis    tool    kit
 
                                    copyright (c) fabian hummel
                                       www.github.com/fshstk
                                           www.fshstk.com
 
         this file is part of the fantastic spatial holophonic synthesis toolkit (fsh::stk)
  fsh::stk is free software: it is provided under the terms of the gnu general public license v3.0
                                    www.gnu.org/licenses/gpl-3.0
***************************************************************************************************/
 
#pragma once
#include <juce_audio_processors/juce_audio_processors.h>
 
// The following macros are here just to appease the compiler. When including this file in a plugin,
// the `JucePlugin_*` constants will always be defined by juce_add_plugin() in CMakeLists.txt.
 
#ifndef JucePlugin_IsSynth
#error "JucePlugin_IsSynth must be defined. Use this class inside of a JUCE project."
const auto JucePlugin_IsSynth = false;
#endif
 
#ifndef JucePlugin_Name
#error "JucePlugin_Name must be defined. Use this class inside of a JUCE project."
const auto JucePlugin_Name = "";
#endif
 
#ifndef JucePlugin_WantsMidiInput
#error "JucePlugin_WantsMidiInput must be defined. Use this class inside of a JUCE project."
const auto JucePlugin_WantsMidiInput = false;
#endif
 
#ifndef JucePlugin_ProducesMidiOutput
#error "JucePlugin_ProducesMidiOutput must be defined. Use this class inside of a JUCE project."
const auto JucePlugin_ProducesMidiOutput = false;
#endif
 
#ifndef JucePlugin_IsMidiEffect
#error "JucePlugin_IsMidiEffect must be defined. Use this class inside of a JUCE project."
const auto JucePlugin_IsMidiEffect = false;
#endif
 
namespace fsh::plugin
{
template<class StateManager>
class Processor : public juce::AudioProcessor
{
public:
  struct Config
  {
    juce::AudioChannelSet outputs; 
 
    juce::AudioChannelSet inputs = juce::AudioChannelSet::disabled();
 
    auto hasInputs() const -> bool { return inputs != juce::AudioChannelSet::disabled(); }
  };
 
  explicit Processor(const Config& conf)
    : AudioProcessor(conf.hasInputs() ? BusesProperties()
                                          .withInput("Input", conf.inputs, true)
                                          .withOutput("Output", conf.outputs, true)
                                      : BusesProperties().withOutput("Output", conf.outputs, true))
    , _params(*this)
    , _conf(conf)
  {
  }
 
  bool isBusesLayoutSupported(const BusesLayout& layouts) const override
  {
    return layouts.getMainInputChannelSet().size() == _conf.inputs.size() &&
           layouts.getMainOutputChannelSet().size() == _conf.outputs.size();
  }
 
  void prepareToPlay(double sampleRate, int maxSamplesPerBlock) override
  {
    juce::ignoreUnused(sampleRate);
    juce::ignoreUnused(maxSamplesPerBlock);
  }
 
  void releaseResources() override
  {
    // Intentionally empty default implementation.
  }
 
  const juce::String getName() const override { return _name; }
 
  double getTailLengthSeconds() const override { return 0.0; }
 
  bool hasEditor() const override { return true; }
 
  virtual std::unique_ptr<juce::AudioProcessorEditor> customEditor() { return {}; }
 
  bool acceptsMidi() const override { return _wantsMidi; }
 
  bool producesMidi() const override { return _producesMidi; }
 
  bool isMidiEffect() const override { return _isMidiEffect; }
 
  int getNumPrograms() override { return 1; }
 
  int getCurrentProgram() override { return 0; }
 
  const juce::String getProgramName(int) override { return "unnamed"; }
 
  void setCurrentProgram(int) override
  {
    // Intentionally empty override
  }
 
  void changeProgramName(int, const juce::String&) override
  {
    // Intentionally empty override
  }
 
  void getStateInformation(juce::MemoryBlock& destData) override
  {
    copyXmlToBinary(_params.getState(), destData);
  }
 
  void setStateInformation(const void* data, int sizeInBytes) override
  {
    if (const auto xml = getXmlFromBinary(data, sizeInBytes))
      _params.setState(*xml);
  }
 
protected:
  StateManager _params;
 
private:
  juce::AudioProcessorEditor* createEditor() final
  {
    if (auto editor = customEditor(); editor)
      return editor.release();
    return new juce::GenericAudioProcessorEditor(*this);
  }
 
  inline static const auto _isSynth = bool{ JucePlugin_IsSynth };
  inline static const auto _name = juce::String{ JucePlugin_Name };
  inline static const auto _wantsMidi = bool{ JucePlugin_WantsMidiInput };
  inline static const auto _producesMidi = bool{ JucePlugin_ProducesMidiOutput };
  inline static const auto _isMidiEffect = bool{ JucePlugin_IsMidiEffect };
  Config _conf;
  juce::ScopedNoDenormals _disableDenormals;
};
} // namespace fsh::plugin