mirror/Magical8bitPlug2
1
0
Fork 0
mirror of https://github.com/yokemura/Magical8bitPlug2.git synced 2025-05-24 23:00:21 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #43 from yokemura/parameterID

Browse Source 
Added ParameterID
This commit is contained in:
Takeshi Yokemura 2024-01-14 19:43:30 +09:00 committed by GitHub
commit f6116fe0b4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 244 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

432
Source/PluginProcessor.cpp
View File

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