Magical8bitPlug2/Source/PluginProcessor.cpp
2024-01-14 22:44:50 +09:00

501 lines
21 KiB
C++

/*
==============================================================================
This file was auto-generated!
It contains the basic framework code for a JUCE plugin processor.
==============================================================================
*/
#include "PluginProcessor.h"
#include "PluginEditor.h"
#include "PulseVoice.h"
#include "TriangleVoice.h"
#include "NoiseVoice.h"
#include "FrameSequenceParseErrors.h"
#include "EnvelopeParserTest.h"
//==============================================================================
Magical8bitPlug2AudioProcessor::Magical8bitPlug2AudioProcessor()
: parameters(
*this, nullptr, Identifier("Params"),
{//
// Meta
//
std::make_unique<AudioParameterBool>(ParameterID{"isAdvancedPanelOpen_raw", 1},
"Advanced",
false),
std::make_unique<AudioParameterChoice>(ParameterID{"colorScheme", 1},
"Color Scheme",
StringArray({"YMCK", "YMCK Dark", "Japan", "Worldwide", "Monotone", "Mono Dark"}),
0),
//
// Basic
//
std::make_unique<AudioParameterChoice>(ParameterID{"osc", 1},
"OSC Type",
StringArray({"Pulse/Square", "Triangle", "Noise"}),
0),
std::make_unique<AudioParameterFloat>(ParameterID{"gain", 1},
"Gain",
0.0f,
1.0f,
0.5f),
std::make_unique<AudioParameterFloat>(ParameterID{"maxPoly", 1},
"Max Poly",
NormalisableRange<float>(1.0f, // min
64.0f, // max
1.0f, // step
1.0f), // skew
8),
//
// ADSR
//
std::make_unique<AudioParameterFloat>(ParameterID{"attack", 1},
"Attack", // name
NormalisableRange<float>(0.0f, // min
5.0f, // max
0.001f, // step
0.5f), // skew
0.0f), // default
std::make_unique<AudioParameterFloat>(ParameterID{"decay", 1},
"Decay", // name
NormalisableRange<float>(0.0f, // min
5.0f, // max
0.001f, // step
0.5f), // skew
0.0f), // default
std::make_unique<AudioParameterFloat>(ParameterID{"suslevel", 1},
"Sustain", // name
0.0f, // min
1.0f, // max
1.0f), // default
std::make_unique<AudioParameterFloat>(ParameterID{"release", 1},
"Release", // name
NormalisableRange<float>(0.0f, // min
5.0f, // max
0.001f, // step
0.5f), // skew
0.0f), // default
//
// Monophonic
//
std::make_unique<AudioParameterChoice>(ParameterID{"monophonicBehavior_raw", 1},
"Behavior",
StringArray({"Legato", "Arpeggio Up", "Arpeggio Down", "Non-legato"}),
0),
std::make_unique<AudioParameterChoice>(ParameterID{"arpeggioIntervalType_raw", 1},
"Interval",
StringArray({"1 frame", "2 frames", "3 frames", "96th", "64th", "48th", "32nd", "24th", "Slider"}),
0),
std::make_unique<AudioParameterFloat>(ParameterID{"arpeggioIntervalSliderValue", 1},
"Interval", // name
NormalisableRange<float>(0.001f, // min
0.3f, // max
0.001f, // step
0.5f), // skew
0.001f), // default
std::make_unique<AudioParameterFloat>(ParameterID{"portamentoTime", 1},
"Portamento Time",
0.0f,
1.0f,
0.0f),
//
// Bend
//
std::make_unique<AudioParameterInt>(ParameterID{"bendRange", 1},
"Bend Range",
0,
24,
2),
//
// Vibrato
//
std::make_unique<AudioParameterFloat>(ParameterID{"vibratoRate", 1},
"Rate", // name
NormalisableRange<float>(0.01f, // min
1.0f, // max
0.001f, // step
0.5f), // skew
0.15f), // default
std::make_unique<AudioParameterFloat>(ParameterID{"vibratoDepth", 1},
"Depth",
0.0f,
2.0f,
0.0f),
std::make_unique<AudioParameterFloat>(ParameterID{"vibratoDelay", 1},
"Delay",
0.0f,
1.0f,
0.3f),
std::make_unique<AudioParameterBool>(ParameterID{"vibratoIgnoresWheel_raw", 1},
"Ignores Wheel",
true),
//
// Sweep
//
std::make_unique<AudioParameterInt>(ParameterID{"sweepInitialPitch", 1},
"Ini.Pitch",
-24,
24,
0),
std::make_unique<AudioParameterFloat>(ParameterID{"sweepTime", 1},
"Time", // name
NormalisableRange<float>(0.01f, // min
5.0f, // max
0.001f, // step
0.5f), // skew
0.1f), // default
//
// For Pulse
//
std::make_unique<AudioParameterChoice>(ParameterID{"duty", 1},
"Duty",
StringArray({"12.5%", "25%", "50%"}),
0),
//
// For Noise
//
std::make_unique<AudioParameterChoice>(ParameterID{"noiseAlgorithm_raw", 1},
"Algorithm", StringArray({"4bit Pure Random", "1bit Long Cycle", "1bit Short Cycle"}),
0),
std::make_unique<AudioParameterBool>(ParameterID{"restrictsToNESFrequency_raw", 1},
"Restricts to NES frequency",
false),
//
// Sequence
//
std::make_unique<AudioParameterBool>(ParameterID{"isVolumeSequenceEnabled_raw", 1},
"Enabled",
false),
std::make_unique<AudioParameterBool>(ParameterID{"isPitchSequenceEnabled_raw", 1},
"Enabled",
false),
std::make_unique<AudioParameterBool>(ParameterID{"isDutySequenceEnabled_raw", 1},
"Enabled",
false),
std::make_unique<AudioParameterChoice>(ParameterID{"pitchSequenceMode_raw", 1},
"Mode",
StringArray({"Coarse", "Fine"}),
0)
}),
settingRefs(&parameters), synth(*this)
#ifndef JucePlugin_PreferredChannelConfigurations
,
AudioProcessor(BusesProperties()
#if !JucePlugin_IsMidiEffect
#if !JucePlugin_IsSynth
.withInput("Input", AudioChannelSet::stereo(), true)
#endif
.withOutput("Output", AudioChannelSet::stereo(), true)
#endif
)
#endif
{
synth.setCurrentPlaybackSampleRate(44100); // Temporary setup, just in case. The actual sample rate is set in prepareToPlay func.
setupVoice();
synth.addSound(new GenericSound());
#if JUCE_DEBUG
EnvelopeParserTest test;
UnitTestRunner runner;
runner.runAllTests();
#endif
}
Magical8bitPlug2AudioProcessor::~Magical8bitPlug2AudioProcessor()
{
}
//==============================================================================
void Magical8bitPlug2AudioProcessor::setupVoice()
{
int poly = synth.getNumVoices();
for (auto i = 0; i < poly; i++)
{
synth.removeVoice(0);
}
int type = roundToInt(*settingRefs.osc);
for (auto i = 0; i < (int)(*settingRefs.maxPoly); ++i)
{
switch (type)
{
case kVoiceTypePulse:
synth.addVoice(new PulseVoice(&settingRefs));
break;
case kVoiceTypeTriangle:
synth.addVoice(new TriangleVoice(&settingRefs));
break;
case kVoiceTypeNoise:
synth.addVoice(new NoiseVoice(&settingRefs));
break;
}
}
}
double Magical8bitPlug2AudioProcessor::getCurrentBPM()
{
double bpm { 120 }; // default fallback when host does not provide info
if (auto bpmFromHost = *getPlayHead()->getPosition()->getBpm())
bpm = bpmFromHost;
return bpm;
}
//==============================================================================
const String Magical8bitPlug2AudioProcessor::getName() const
{
return JucePlugin_Name;
}
bool Magical8bitPlug2AudioProcessor::acceptsMidi() const
{
#if JucePlugin_WantsMidiInput
return true;
#else
return false;
#endif
}
bool Magical8bitPlug2AudioProcessor::producesMidi() const
{
#if JucePlugin_ProducesMidiOutput
return true;
#else
return false;
#endif
}
bool Magical8bitPlug2AudioProcessor::isMidiEffect() const
{
#if JucePlugin_IsMidiEffect
return true;
#else
return false;
#endif
}
double Magical8bitPlug2AudioProcessor::getTailLengthSeconds() const
{
return 0.0;
}
int Magical8bitPlug2AudioProcessor::getNumPrograms()
{
return 1; // NB: some hosts don't cope very well if you tell them there are 0 programs,
// so this should be at least 1, even if you're not really implementing programs.
}
int Magical8bitPlug2AudioProcessor::getCurrentProgram()
{
return 0;
}
void Magical8bitPlug2AudioProcessor::setCurrentProgram(int index)
{
}
const String Magical8bitPlug2AudioProcessor::getProgramName(int index)
{
return {};
}
void Magical8bitPlug2AudioProcessor::changeProgramName(int index, const String &newName)
{
}
//==============================================================================
void Magical8bitPlug2AudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
{
// Use this method as the place to do any pre-playback
// initialisation that you need..
synth.setCurrentPlaybackSampleRate(sampleRate);
}
void Magical8bitPlug2AudioProcessor::releaseResources()
{
// When playback stops, you can use this as an opportunity to free up any
// spare memory, etc.
}
#ifndef JucePlugin_PreferredChannelConfigurations
bool Magical8bitPlug2AudioProcessor::isBusesLayoutSupported(const BusesLayout &layouts) const
{
#if JucePlugin_IsMidiEffect
ignoreUnused(layouts);
return true;
#else
// This is the place where you check if the layout is supported.
// In this template code we only support mono or stereo.
if (layouts.getMainOutputChannelSet() != AudioChannelSet::mono() && layouts.getMainOutputChannelSet() != AudioChannelSet::stereo())
return false;
// This checks if the input layout matches the output layout
#if !JucePlugin_IsSynth
if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())
return false;
#endif
return true;
#endif
}
#endif
void Magical8bitPlug2AudioProcessor::processBlock(AudioBuffer<float> &buffer, MidiBuffer &midiMessages)
{
buffer.clear();
synth.renderNextBlock(buffer, midiMessages, 0, buffer.getNumSamples());
}
//==============================================================================
bool Magical8bitPlug2AudioProcessor::hasEditor() const
{
return true;
}
AudioProcessorEditor *Magical8bitPlug2AudioProcessor::createEditor()
{
return new Magical8bitPlug2AudioProcessorEditor(*this);
}
//==============================================================================
void Magical8bitPlug2AudioProcessor::getStateInformation(MemoryBlock &destData)
{
auto state = parameters.copyState();
XmlElement *rootElement = new XmlElement("root");
std::unique_ptr<XmlElement> stateElement = std::unique_ptr<XmlElement>(state.createXml());
rootElement->addChildElement(stateElement.get());
stateElement.release(); // give up the ownership already because xml object will delete it
XmlElement *volEnvElement = new XmlElement("volumeEnv");
XmlElement *pitEnvElement = new XmlElement("pitchEnv");
XmlElement *dutEnvElement = new XmlElement("dutyEnv");
volEnvElement->addTextElement(settingRefs.volumeSequenceString);
pitEnvElement->addTextElement(settingRefs.pitchSequenceString);
dutEnvElement->addTextElement(settingRefs.dutySequenceString);
rootElement->addChildElement(volEnvElement);
rootElement->addChildElement(pitEnvElement);
rootElement->addChildElement(dutEnvElement);
std::unique_ptr<XmlElement> xml(rootElement);
copyXmlToBinary(*xml, destData);
}
void Magical8bitPlug2AudioProcessor::setStateInformation(const void *data, int sizeInBytes)
{
std::unique_ptr<XmlElement> xmlState(getXmlFromBinary(data, sizeInBytes));
if (xmlState.get() != nullptr)
{
if (xmlState->hasTagName("root"))
{
// ValueTree
XmlElement *valueTreeXml = xmlState->getChildByName(parameters.state.getType());
if (valueTreeXml != nullptr)
{
parameters.replaceState(ValueTree::fromXml(*valueTreeXml));
}
else
{
printf("Saved plugin parameters are incompatible");
}
// Custom Env
XmlElement *volumeEnvXml = xmlState->getChildByName("volumeEnv");
XmlElement *pitchEnvXml = xmlState->getChildByName("pitchEnv");
XmlElement *dutyEnvXml = xmlState->getChildByName("dutyEnv");
if (volumeEnvXml != nullptr)
{
XmlElement *volElem = volumeEnvXml->getFirstChildElement();
if (volElem != nullptr && volElem->isTextElement())
{
String volStr = volElem->getText();
ParseError err = kParseErrorNone;
settingRefs.setSequenceWithString("volume", volStr, &err);
if (settingRefs.volumeSequenceListener != nullptr)
{
settingRefs.volumeSequenceListener->sequenceChanged(volStr);
}
Logger::writeToLog("volume seq = " + volStr);
}
else
{
Logger::writeToLog("volumeEnv entry found, but seems not like a text element.");
}
}
if (pitchEnvXml != nullptr)
{
XmlElement *pitElem = pitchEnvXml->getFirstChildElement();
if (pitElem != nullptr && pitElem->isTextElement())
{
String pitStr = pitElem->getText();
ParseError err = kParseErrorNone;
settingRefs.setSequenceWithString("pitch", pitStr, &err);
if (settingRefs.pitchSequenceListener != nullptr)
{
settingRefs.pitchSequenceListener->sequenceChanged(pitStr);
}
Logger::writeToLog("pitch seq = " + pitStr);
}
else
{
Logger::writeToLog("pitchEnv entry found, but seems not like a text element.");
}
}
if (dutyEnvXml != nullptr)
{
XmlElement *dutElem = dutyEnvXml->getFirstChildElement();
if (dutElem != nullptr && dutElem->isTextElement())
{
String dutStr = dutElem->getText();
ParseError err = kParseErrorNone;
settingRefs.setSequenceWithString("duty", dutStr, &err);
if (settingRefs.dutySequenceListener != nullptr)
{
settingRefs.dutySequenceListener->sequenceChanged(dutStr);
}
Logger::writeToLog("duty seq = " + dutStr);
}
else
{
Logger::writeToLog("dutyEnv entry found, but seems not like a text element.");
}
}
}
}
setupVoice();
}
//==============================================================================
// This creates new instances of the plugin..
AudioProcessor *JUCE_CALLTYPE createPluginFilter()
{
return new Magical8bitPlug2AudioProcessor();
}