mirrors/OB-Xd
2
0
Fork 0
Code Activity
OB-Xd/Source/PluginProcessor.cpp
George Reales 39fb65be68 MIDI learn and clear
2020-07-16 10:14:56 +02:00

1037 lines
30 KiB
C++
Executable file
Raw Blame History

/*
==============================================================================
This file was auto-generated!
It contains the basic startup code for a Juce application.
==============================================================================
*/
#include "PluginProcessor.h"
#include "PluginEditor.h"
#include "Engine/Params.h"
// Compare JUCE_VERSION against this to check for JUCE 5.4.3 and earlier
#define JUCE_543 328707
//only sse2 version on windows
#ifdef _WINDOWS
#define __SSE2__
#define __SSE__
#endif
#ifdef __SSE2__
#include <xmmintrin.h>
#endif
//==============================================================================
#define S(T) (juce::String(T))
//==============================================================================
AudioProcessorValueTreeState::ParameterLayout createParameterLayout()
{
ObxdParams defaultParams;
std::vector<std::unique_ptr<AudioParameterFloat>> params;
for (int i = 0; i < PARAM_COUNT; ++i)
{
auto id = ObxdAudioProcessor::getEngineParameterId (i);
auto name = TRANS (id);
auto range = NormalisableRange<float> {0.0f, 1.0f};
auto defaultValue = defaultParams.values[i];
auto parameter = std::make_unique<AudioParameterFloat> (id,
name,
range,
defaultValue);
params.push_back (std::move (parameter));
}
return { params.begin(), params.end() };
}
//==============================================================================
ObxdAudioProcessor::ObxdAudioProcessor()
: bindings()
, programs()
, configLock("__" JucePlugin_Name "ConfigLock__")
, apvtState (*this, &undoManager, "PARAMETERS", createParameterLayout())
{
isHostAutomatedChange = true;
midiControlledParamSet = false;
lastMovedController = 0;
lastUsedParameter = 0;
synth.setSampleRate (44100);
PropertiesFile::Options options;
options.applicationName = JucePlugin_Name;
options.storageFormat = PropertiesFile::storeAsXML;
options.millisecondsBeforeSaving = 2500;
options.processLock = &configLock;
config = std::unique_ptr<PropertiesFile> (new PropertiesFile (getDocumentFolder().getChildFile ("Settings.xml"), options));
currentSkin = config->containsKey("skin") ? config->getValue("skin") : "discoDSP Blue";
currentBank = "Init";
scanAndUpdateBanks();
scanAndUpdateSkins();
initAllParams();
if (bankFiles.size() > 0)
{
loadFromFXBFile (bankFiles[0]);
}
for (int i = 0; i < PARAM_COUNT; ++i)
{
apvtState.addParameterListener (getEngineParameterId (i), this);
}
apvtState.state = ValueTree (JucePlugin_Name);
}
ObxdAudioProcessor::~ObxdAudioProcessor()
{
config->saveIfNeeded();
config = nullptr;
}
//==============================================================================
void ObxdAudioProcessor::initAllParams()
{
for (int i = 0; i < PARAM_COUNT; ++i)
{
setEngineParameterValue (i, programs.currentProgramPtr->values[i]);
}
}
//==============================================================================
const String ObxdAudioProcessor::getName() const
{
return JucePlugin_Name;
}
const String ObxdAudioProcessor::getInputChannelName (int channelIndex) const
{
return String (channelIndex + 1);
}
const String ObxdAudioProcessor::getOutputChannelName (int channelIndex) const
{
return String (channelIndex + 1);
}
bool ObxdAudioProcessor::isInputChannelStereoPair (int index) const
{
return true;
}
bool ObxdAudioProcessor::isOutputChannelStereoPair (int index) const
{
return true;
}
bool ObxdAudioProcessor::acceptsMidi() const
{
#if JucePlugin_WantsMidiInput
return true;
#else
return false;
#endif
}
bool ObxdAudioProcessor::producesMidi() const
{
#if JucePlugin_ProducesMidiOutput
return true;
#else
return false;
#endif
}
double ObxdAudioProcessor::getTailLengthSeconds() const
{
return 0.0;
}
//==============================================================================
int ObxdAudioProcessor::getNumPrograms()
{
return PROGRAMCOUNT;
}
int ObxdAudioProcessor::getCurrentProgram()
{
return programs.currentProgram;
}
void ObxdAudioProcessor::setCurrentProgram (int index)
{
programs.currentProgram = index;
programs.currentProgramPtr = programs.programs + programs.currentProgram;
isHostAutomatedChange = false;
for (int i = 0; i < PARAM_COUNT; ++i)
setEngineParameterValue (i, programs.currentProgramPtr->values[i]);
isHostAutomatedChange = true;
sendChangeMessage();
updateHostDisplay();
}
const String ObxdAudioProcessor::getProgramName (int index)
{
return programs.programs[index].name;
}
void ObxdAudioProcessor::changeProgramName (int index, const String& newName)
{
programs.programs[index].name = newName;
}
//==============================================================================
void ObxdAudioProcessor::prepareToPlay (double sampleRate, int /*samplesPerBlock*/)
{
// Use this method as the place to do any pre-playback
// initialisation that you need..
nextMidi = new MidiMessage (0xF0);
midiMsg = new MidiMessage (0xF0);
synth.setSampleRate (sampleRate);
}
void ObxdAudioProcessor::releaseResources()
{
}
inline void ObxdAudioProcessor::processMidiPerSample (MidiBuffer::Iterator* iter, const int samplePos)
{
while (getNextEvent (iter, samplePos))
{
if (midiMsg->isNoteOn())
{
synth.procNoteOn (midiMsg->getNoteNumber(), midiMsg->getFloatVelocity());
}
if (midiMsg->isNoteOff())
{
synth.procNoteOff (midiMsg->getNoteNumber());
}
if (midiMsg->isPitchWheel())
{
// [0..16383] center = 8192;
synth.procPitchWheel ((midiMsg->getPitchWheelValue() - 8192) / 8192.0f);
}
if (midiMsg->isController() && midiMsg->getControllerNumber() == 1)
{
synth.procModWheel (midiMsg->getControllerValue() / 127.0f);
}
if (midiMsg->isController())
{
lastMovedController = midiMsg->getControllerNumber();
if (programs.currentProgramPtr->values[MIDILEARN] > 0.5f){
midiControlledParamSet = true;
bindings[lastMovedController] = lastUsedParameter;
setEngineParameterValue (MIDILEARN, 0, true);
lastMovedController = 0;
lastUsedParameter = 0;
midiControlledParamSet = false;
}
if (bindings[lastMovedController] > 0)
{
midiControlledParamSet = true;
setEngineParameterValue (bindings[lastMovedController],
midiMsg->getControllerValue() / 127.0f);
setEngineParameterValue (MIDILEARN, 0);
lastMovedController = 0;
lastUsedParameter = 0;
midiControlledParamSet = false;
}
}
if(midiMsg->isSustainPedalOn())
{
synth.sustainOn();
}
if(midiMsg->isSustainPedalOff() || midiMsg->isAllNotesOff()||midiMsg->isAllSoundOff())
{
synth.sustainOff();
}
if(midiMsg->isAllNotesOff())
{
synth.allNotesOff();
}
if(midiMsg->isAllSoundOff())
{
synth.allSoundOff();
}
}
}
bool ObxdAudioProcessor::getNextEvent (MidiBuffer::Iterator* iter, const int samplePos)
{
if (hasMidiMessage && midiEventPos <= samplePos)
{
*midiMsg = *nextMidi;
hasMidiMessage = iter->getNextEvent (*nextMidi, midiEventPos);
return true;
}
return false;
}
void ObxdAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
//SSE flags set
#ifdef __SSE__
_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
#endif
#ifdef __SSE2__
// _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
#endif
MidiBuffer::Iterator ppp (midiMessages);
hasMidiMessage = ppp.getNextEvent (*nextMidi, midiEventPos);
int samplePos = 0;
int numSamples = buffer.getNumSamples();
float* channelData1 = buffer.getWritePointer (0);
float* channelData2 = buffer.getWritePointer (1);
AudioPlayHead::CurrentPositionInfo pos;
if (getPlayHead() != 0 && getPlayHead()->getCurrentPosition (pos))
{
synth.setPlayHead(pos.bpm, pos.ppqPosition);
}
while (samplePos < numSamples)
{
processMidiPerSample (&ppp, samplePos);
synth.processSample (channelData1+samplePos, channelData2+samplePos);
++samplePos;
}
}
//==============================================================================
bool ObxdAudioProcessor::hasEditor() const
{
return true;
}
AudioProcessorEditor* ObxdAudioProcessor::createEditor()
{
return new ObxdAudioProcessorEditor (*this);
}
//==============================================================================
void ObxdAudioProcessor::getStateInformation(MemoryBlock& destData)
{
XmlElement xmlState = XmlElement("discoDSP");
xmlState.setAttribute(S("currentProgram"), programs.currentProgram);
XmlElement* xprogs = new XmlElement("programs");
for (int i = 0; i < PROGRAMCOUNT; ++i)
{
XmlElement* xpr = new XmlElement("program");
xpr->setAttribute(S("programName"), programs.programs[i].name);
xpr->setAttribute(S("voiceCount"), Motherboard::MAX_VOICES);
for (int k = 0; k < PARAM_COUNT; ++k)
{
xpr->setAttribute("Val_" + String(k), programs.programs[i].values[k]);
}
xprogs->addChildElement(xpr);
}
xmlState.addChildElement(xprogs);
bindings.setXml(xmlState);
copyXmlToBinary(xmlState, destData);
}
void ObxdAudioProcessor::getCurrentProgramStateInformation(MemoryBlock& destData)
{
XmlElement xmlState = XmlElement("discoDSP");
for (int k = 0; k < PARAM_COUNT; ++k)
{
xmlState.setAttribute("Val_" + String(k), programs.currentProgramPtr->values[k]);
}
xmlState.setAttribute(S("voiceCount"), Motherboard::MAX_VOICES);
xmlState.setAttribute(S("programName"), programs.currentProgramPtr->name);
copyXmlToBinary(xmlState, destData);
}
void ObxdAudioProcessor::setStateInformation(const void* data, int sizeInBytes)
{
#if JUCE_VERSION <= JUCE_543
XmlElement * const xmlState = getXmlFromBinary(data, sizeInBytes);
#else
std::unique_ptr<XmlElement> xmlState = getXmlFromBinary(data, sizeInBytes);
#endif
if (xmlState)
{
XmlElement* xprogs = xmlState->getFirstChildElement();
if (xprogs->hasTagName(S("programs")))
{
int i = 0;
forEachXmlChildElement(*xprogs, e)
{
bool newFormat = e->hasAttribute("voiceCount");
programs.programs[i].setDefaultValues();
for (int k = 0; k < PARAM_COUNT; ++k)
{
float value = 0.0;
if (e->hasAttribute("Val_" + String(k))){
value = float(e->getDoubleAttribute("Val_" + String(k), programs.programs[i].values[k]));
} else {
value = float(e->getDoubleAttribute(String(k), programs.programs[i].values[k]));
}
if (!newFormat && k == VOICE_COUNT) value *= 0.25f;
programs.programs[i].values[k] = value;
}
programs.programs[i].name = e->getStringAttribute(S("programName"), S("Default"));
++i;
}
}
bindings.getXml(*xmlState);
#if ! DEMOVERSION
setCurrentProgram(xmlState->getIntAttribute(S("currentProgram"), 0));
sendChangeMessage();
#endif
#if JUCE_VERSION <= JUCE_543
delete xmlState;
#endif
}
}
void ObxdAudioProcessor::setCurrentProgramStateInformation(const void* data, int sizeInBytes)
{
#if JUCE_VERSION <= JUCE_543
XmlElement * const e = getXmlFromBinary(data, sizeInBytes);
#else
std::unique_ptr<XmlElement> e = getXmlFromBinary(data, sizeInBytes);
#endif
if (e)
{
programs.currentProgramPtr->setDefaultValues();
bool newFormat = e->hasAttribute("voiceCount");
for (int k = 0; k < PARAM_COUNT; ++k)
{
float value = 0.0 ;
if (e->hasAttribute("Val_" + String(k))){
value = float(e->getDoubleAttribute("Val_" + String(k), programs.currentProgramPtr->values[k]));
} else {
value = float(e->getDoubleAttribute(String(k), programs.currentProgramPtr->values[k]));
}
if (!newFormat && k == VOICE_COUNT) value *= 0.25f;
programs.currentProgramPtr->values[k] = value;
}
programs.currentProgramPtr->name = e->getStringAttribute(S("programName"), S("Default"));
setCurrentProgram(programs.currentProgram);
sendChangeMessage();
#if JUCE_VERSION <= JUCE_543
delete e;
#endif
}
}
//==============================================================================
bool ObxdAudioProcessor::loadFromFXBFile(const File& fxbFile)
{
MemoryBlock mb;
if (! fxbFile.loadFileAsData(mb))
return false;
const void* const data = mb.getData();
const size_t dataSize = mb.getSize();
if (dataSize < 28)
return false;
const fxSet* const set = (const fxSet*) data;
if ((! compareMagic (set->chunkMagic, "CcnK")) || fxbSwap (set->version) > fxbVersionNum)
return false;
if (compareMagic (set->fxMagic, "FxBk"))
{
// bank of programs
if (fxbSwap (set->numPrograms) >= 0)
{
const int oldProg = getCurrentProgram();
const int numParams = fxbSwap (((const fxProgram*) (set->programs))->numParams);
const int progLen = (int) sizeof (fxProgram) + (numParams - 1) * (int) sizeof (float);
for (int i = 0; i < fxbSwap (set->numPrograms); ++i)
{
if (i != oldProg)
{
const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + i * progLen);
if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)
return false;
if (fxbSwap (set->numPrograms) > 0)
setCurrentProgram (i);
if (! restoreProgramSettings (prog))
return false;
}
}
if (fxbSwap (set->numPrograms) > 0)
setCurrentProgram (oldProg);
const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + oldProg * progLen);
if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)
return false;
if (! restoreProgramSettings (prog))
return false;
}
}
else if (compareMagic (set->fxMagic, "FxCk"))
{
// single program
const fxProgram* const prog = (const fxProgram*) data;
if (! compareMagic (prog->chunkMagic, "CcnK"))
return false;
changeProgramName (getCurrentProgram(), prog->prgName);
for (int i = 0; i < fxbSwap (prog->numParams); ++i)
setEngineParameterValue (i, fxbSwapFloat (prog->params[i]));
}
else if (compareMagic (set->fxMagic, "FBCh"))
{
// non-preset chunk
const fxChunkSet* const cset = (const fxChunkSet*) data;
if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxChunkSet) - 8 > (size_t) dataSize)
return false;
setStateInformation(cset->chunk, fxbSwap (cset->chunkSize));
}
else if (compareMagic (set->fxMagic, "FPCh"))
{
// preset chunk
const fxProgramSet* const cset = (const fxProgramSet*) data;
if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxProgramSet) - 8 > (size_t) dataSize)
return false;
setCurrentProgramStateInformation(cset->chunk, fxbSwap (cset->chunkSize));
changeProgramName (getCurrentProgram(), cset->name);
}
else
{
return false;
}
currentBank = fxbFile.getFileName();
updateHostDisplay();
return true;
}
bool ObxdAudioProcessor::restoreProgramSettings(const fxProgram* const prog)
{
if (compareMagic (prog->chunkMagic, "CcnK")
&& compareMagic (prog->fxMagic, "FxCk"))
{
changeProgramName (getCurrentProgram(), prog->prgName);
for (int i = 0; i < fxbSwap (prog->numParams); ++i)
setEngineParameterValue (i, fxbSwapFloat (prog->params[i]));
return true;
}
return false;
}
//==============================================================================
void ObxdAudioProcessor::scanAndUpdateBanks()
{
bankFiles.clearQuick();
DirectoryIterator it (getBanksFolder(), false, "*.fxb", File::findFiles);
while (it.next())
{
bankFiles.addUsingDefaultSort (it.getFile());
}
}
void ObxdAudioProcessor::scanAndUpdateSkins()
{
skinFiles.clearQuick();
DirectoryIterator it (getSkinFolder(), false, "*", File::findDirectories);
while (it.next())
{
skinFiles.addUsingDefaultSort (it.getFile());
}
}
const Array<File>& ObxdAudioProcessor::getBankFiles() const
{
return bankFiles;
}
const Array<File>& ObxdAudioProcessor::getSkinFiles() const
{
return skinFiles;
}
File ObxdAudioProcessor::getCurrentBankFile() const
{
return getBanksFolder().getChildFile(currentBank);
}
//==============================================================================
File ObxdAudioProcessor::getDocumentFolder() const
{
File folder = File::getSpecialLocation(File::userDocumentsDirectory).getChildFile("discoDSP").getChildFile("OB-Xd");
/*
if (! folder.exists())
{
NativeMessageBox::showMessageBox(AlertWindow::WarningIcon, "Error", "Documents > discoDSP > OB-Xd folder not found.");
}
*/
if (folder.isSymbolicLink())
folder = folder.getLinkedTarget();
return folder;
}
File ObxdAudioProcessor::getSkinFolder() const
{
return getDocumentFolder().getChildFile("Themes");
}
File ObxdAudioProcessor::getBanksFolder() const
{
return getDocumentFolder().getChildFile("Banks");
}
File ObxdAudioProcessor::getCurrentSkinFolder() const
{
return getSkinFolder().getChildFile(currentSkin);
}
void ObxdAudioProcessor::setCurrentSkinFolder(const String& folderName)
{
currentSkin = folderName;
config->setValue("skin", folderName);
config->setNeedsToBeSaved(true);
}
//==============================================================================
String ObxdAudioProcessor::getEngineParameterId (size_t index)
{
switch (index)
{
case SELF_OSC_PUSH: return "SelfOscPush";
case ENV_PITCH_BOTH: return "EnvPitchBoth";
case FENV_INVERT: return "FenvInvert";
case PW_OSC2_OFS: return "PwOfs";
case LEVEL_DIF: return "LevelDif";
case PW_ENV_BOTH: return "PwEnvBoth";
case PW_ENV: return "PwEnv";
case LFO_SYNC: return "LfoSync";
case ECONOMY_MODE: return "EconomyMode";
case UNLEARN: return "MidiUnlearn";
case MIDILEARN: return "MidiLearn";
case VAMPENV: return "VAmpFactor";
case VFLTENV: return "VFltFactor";
case ASPLAYEDALLOCATION: return "AsPlayedAllocation";
case BENDLFORATE: return "VibratoRate";
case FOURPOLE: return "FourPole";
case LEGATOMODE: return "LegatoMode";
case ENVPITCH: return "EnvelopeToPitch";
case OSCQuantize: return "PitchQuant";
case VOICE_COUNT: return "VoiceCount";
case BANDPASS: return "BandpassBlend";
case FILTER_WARM: return "Filter_Warm";
case BENDRANGE: return "BendRange";
case BENDOSC2: return "BendOsc2Only";
case OCTAVE: return "Octave";
case TUNE: return "Tune";
case BRIGHTNESS: return "Brightness";
case NOISEMIX: return "NoiseMix";
case OSC1MIX: return "Osc1Mix";
case OSC2MIX: return "Osc2Mix";
case MULTIMODE: return "Multimode";
case LFOSHWAVE: return "LfoSampleHoldWave";
case LFOSINWAVE: return "LfoSineWave";
case LFOSQUAREWAVE: return "LfoSquareWave";
case LFO1AMT: return "LfoAmount1";
case LFO2AMT: return "LfoAmount2";
case LFOFILTER: return "LfoFilter";
case LFOOSC1: return "LfoOsc1";
case LFOOSC2: return "LfoOsc2";
case LFOFREQ: return "LfoFrequency";
case LFOPW1: return "LfoPw1";
case LFOPW2: return "LfoPw2";
case PORTADER: return "PortamentoDetune";
case FILTERDER: return "FilterDetune";
case ENVDER: return "EnvelopeDetune";
case PAN1: return "Pan1";
case PAN2: return "Pan2";
case PAN3: return "Pan3";
case PAN4: return "Pan4";
case PAN5: return "Pan5";
case PAN6: return "Pan6";
case PAN7: return "Pan7";
case PAN8: return "Pan8";
case XMOD: return "Xmod";
case OSC2HS: return "Osc2HardSync";
case OSC1P: return "Osc1Pitch";
case OSC2P: return "Osc2Pitch";
case PORTAMENTO: return "Portamento";
case UNISON: return "Unison";
case FLT_KF: return "FilterKeyFollow";
case PW: return "PulseWidth";
case OSC2Saw: return "Osc2Saw";
case OSC1Saw: return "Osc1Saw";
case OSC1Pul: return "Osc1Pulse";
case OSC2Pul: return "Osc2Pulse";
case VOLUME: return "Volume";
case UDET: return "VoiceDetune";
case OSC2_DET: return "Oscillator2detune";
case CUTOFF: return "Cutoff";
case RESONANCE: return "Resonance";
case ENVELOPE_AMT: return "FilterEnvAmount";
case LATK: return "Attack";
case LDEC: return "Decay";
case LSUS: return "Sustain";
case LREL: return "Release";
case FATK: return "FilterAttack";
case FDEC: return "FilterDecay";
case FSUS: return "FilterSustain";
case FREL: return "FilterRelease";
default:
break;
}
return "Undefined";
}
int ObxdAudioProcessor::getParameterIndexFromId (String paramId)
{
for (size_t i = 0; i < PARAM_COUNT; ++i)
{
if (paramId.compare (getEngineParameterId (i)) == 0)
{
return int (i);
}
}
return -1;
}
void ObxdAudioProcessor::setEngineParameterValue (int index, float newValue, bool notifyToHost)
{
if (! midiControlledParamSet || index == MIDILEARN || index == UNLEARN)
{
lastUsedParameter = index;
}
programs.currentProgramPtr->values[index] = newValue;
if (notifyToHost){
apvtState.getParameter(getEngineParameterId(index))->setValueNotifyingHost(newValue);
} else {
apvtState.getParameter(getEngineParameterId(index))->setValue(newValue);
}
switch (index)
{
case SELF_OSC_PUSH:
synth.processSelfOscPush (newValue);
break;
case PW_ENV_BOTH:
synth.processPwEnvBoth (newValue);
break;
case PW_OSC2_OFS:
synth.processPwOfs (newValue);
break;
case ENV_PITCH_BOTH:
synth.processPitchModBoth (newValue);
break;
case FENV_INVERT:
synth.processInvertFenv (newValue);
break;
case LEVEL_DIF:
synth.processLoudnessDetune (newValue);
break;
case PW_ENV:
synth.processPwEnv (newValue);
break;
case LFO_SYNC:
synth.procLfoSync (newValue);
break;
case ECONOMY_MODE:
synth.procEconomyMode (newValue);
break;
case VAMPENV:
synth.procAmpVelocityAmount (newValue);
break;
case VFLTENV:
synth.procFltVelocityAmount (newValue);
break;
case ASPLAYEDALLOCATION:
synth.procAsPlayedAlloc (newValue);
break;
case BENDLFORATE:
synth.procModWheelFrequency (newValue);
break;
case FOURPOLE:
synth.processFourPole (newValue);
break;
case LEGATOMODE:
synth.processLegatoMode (newValue);
break;
case ENVPITCH:
synth.processEnvelopeToPitch (newValue);
break;
case OSCQuantize:
synth.processPitchQuantization (newValue);
break;
case VOICE_COUNT:
synth.setVoiceCount (newValue);
break;
case BANDPASS:
synth.processBandpassSw (newValue);
break;
case FILTER_WARM:
synth.processOversampling (newValue);
break;
case BENDOSC2:
synth.procPitchWheelOsc2Only (newValue);
break;
case BENDRANGE:
synth.procPitchWheelAmount (newValue);
break;
case NOISEMIX:
synth.processNoiseMix (newValue);
break;
case OCTAVE:
synth.processOctave (newValue);
break;
case TUNE:
synth.processTune (newValue);
break;
case BRIGHTNESS:
synth.processBrightness (newValue);
break;
case MULTIMODE:
synth.processMultimode (newValue);
break;
case LFOFREQ:
synth.processLfoFrequency (newValue);
break;
case LFO1AMT:
synth.processLfoAmt1 (newValue);
break;
case LFO2AMT:
synth.processLfoAmt2 (newValue);
break;
case LFOSINWAVE:
synth.processLfoSine (newValue);
break;
case LFOSQUAREWAVE:
synth.processLfoSquare (newValue);
break;
case LFOSHWAVE:
synth.processLfoSH (newValue);
break;
case LFOFILTER:
synth.processLfoFilter (newValue);
break;
case LFOOSC1:
synth.processLfoOsc1 (newValue);
break;
case LFOOSC2:
synth.processLfoOsc2 (newValue);
break;
case LFOPW1:
synth.processLfoPw1 (newValue);
break;
case LFOPW2:
synth.processLfoPw2 (newValue);
break;
case PORTADER:
synth.processPortamentoDetune (newValue);
break;
case FILTERDER:
synth.processFilterDetune (newValue);
break;
case ENVDER:
synth.processEnvelopeDetune (newValue);
break;
case XMOD:
synth.processOsc2Xmod (newValue);
break;
case OSC2HS:
synth.processOsc2HardSync (newValue);
break;
case OSC2P:
synth.processOsc2Pitch (newValue);
break;
case OSC1P:
synth.processOsc1Pitch (newValue);
break;
case PORTAMENTO:
synth.processPortamento (newValue);
break;
case UNISON:
synth.processUnison (newValue);
break;
case FLT_KF:
synth.processFilterKeyFollow (newValue);
break;
case OSC1MIX:
synth.processOsc1Mix (newValue);
break;
case OSC2MIX:
synth.processOsc2Mix (newValue);
break;
case PW:
synth.processPulseWidth (newValue);
break;
case OSC1Saw:
synth.processOsc1Saw (newValue);
break;
case OSC2Saw:
synth.processOsc2Saw (newValue);
break;
case OSC1Pul:
synth.processOsc1Pulse (newValue);
break;
case OSC2Pul:
synth.processOsc2Pulse (newValue);
break;
case VOLUME:
synth.processVolume (newValue);
break;
case UDET:
synth.processDetune (newValue);
break;
case OSC2_DET:
synth.processOsc2Det (newValue);
break;
case CUTOFF:
synth.processCutoff (newValue);
break;
case RESONANCE:
synth.processResonance (newValue);
break;
case ENVELOPE_AMT:
synth.processFilterEnvelopeAmt (newValue);
break;
case LATK:
synth.processLoudnessEnvelopeAttack (newValue);
break;
case LDEC:
synth.processLoudnessEnvelopeDecay (newValue);
break;
case LSUS:
synth.processLoudnessEnvelopeSustain (newValue);
break;
case LREL:
synth.processLoudnessEnvelopeRelease (newValue);
break;
case FATK:
synth.processFilterEnvelopeAttack (newValue);
break;
case FDEC:
synth.processFilterEnvelopeDecay (newValue);
break;
case FSUS:
synth.processFilterEnvelopeSustain (newValue);
break;
case FREL:
synth.processFilterEnvelopeRelease (newValue);
break;
case PAN1:
synth.processPan (newValue,1);
break;
case PAN2:
synth.processPan (newValue,2);
break;
case PAN3:
synth.processPan (newValue,3);
break;
case PAN4:
synth.processPan (newValue,4);
break;
case PAN5:
synth.processPan (newValue,5);
break;
case PAN6:
synth.processPan (newValue,6);
break;
case PAN7:
synth.processPan (newValue,7);
break;
case PAN8:
synth.processPan (newValue,8);
break;
}
//DIRTY HACK
//This should be checked to avoid stalling on gui update
//It is needed because some hosts do wierd stuff
if (isHostAutomatedChange)
sendChangeMessage();
}
//==============================================================================
void ObxdAudioProcessor::parameterChanged (const String& parameter, float newValue)
{
int index = getParameterIndexFromId (parameter);
if ( isPositiveAndBelow (index, PARAM_COUNT) )
{
setEngineParameterValue (index, newValue);
}
}
AudioProcessorValueTreeState& ObxdAudioProcessor::getPluginState()
{
return apvtState;
}
//==============================================================================
// This creates new instances of the plugin..
AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
return new ObxdAudioProcessor();
}
View git blame Copy permalink