Kwidget_CoreEngine.cpp

Go to the documentation of this file.

namespace krotos
{
    const String Kwidget_CoreEngine::Parameters::Start = "Start";
    const String Kwidget_CoreEngine::Parameters::Size = "Size";
    const String Kwidget_CoreEngine::Parameters::Rate = "Rate";
    const String Kwidget_CoreEngine::Parameters::Pitch = "Pitch";
    const String Kwidget_CoreEngine::Parameters::PitchMod = "PitchMod";
    const String Kwidget_CoreEngine::Parameters::Width = "Width";
    const String Kwidget_CoreEngine::Parameters::Pan = "Pan";
    const String Kwidget_CoreEngine::Parameters::Level = "Level";
    const String Kwidget_CoreEngine::Parameters::SamplerLevel = "SamplerLevel";
    const String Kwidget_CoreEngine::Parameters::GranularLevel = "GranularLevel";
    const String Kwidget_CoreEngine::Parameters::VehicleLevel = "VehicleLevel";
    const String Kwidget_CoreEngine::Parameters::LevelMod = "LevelMod";
    const String Kwidget_CoreEngine::Parameters::StartRand = "StartRand";
    const String Kwidget_CoreEngine::Parameters::SizeRand = "SizeRand";
    const String Kwidget_CoreEngine::Parameters::RateRand = "RateRand";
    const String Kwidget_CoreEngine::Parameters::PitchRand = "PitchRand";
    const String Kwidget_CoreEngine::Parameters::WidthRand = "WidthRand";
    const String Kwidget_CoreEngine::Parameters::PanRand = "PanRand";
    const String Kwidget_CoreEngine::Parameters::LevelRand = "LevelRand";
    const String Kwidget_CoreEngine::Parameters::Quench = "Quench";
    const String Kwidget_CoreEngine::Parameters::NOR = "NOR";
    const String Kwidget_CoreEngine::Parameters::Robin = "Robin";
    const String Kwidget_CoreEngine::Parameters::SALoop = "SALoop";
    const String Kwidget_CoreEngine::Parameters::AutoRate = "AutoRate";
    const String Kwidget_CoreEngine::Parameters::PhaseLock = "PhaseLock";
    const String Kwidget_CoreEngine::Parameters::PhaseSync = "PhaseSync";
    const String Kwidget_CoreEngine::Parameters::Normalise = "Normalise";
    const String Kwidget_CoreEngine::Parameters::MuteUp = "MuteUp";
    const String Kwidget_CoreEngine::Parameters::MuteDown = "MuteDown";
    const String Kwidget_CoreEngine::Parameters::Autoplay = "Autoplay";
    const String Kwidget_CoreEngine::Parameters::Shape = "Shape";
    const String Kwidget_CoreEngine::Parameters::GrainMax = "GrainMax";
    const String Kwidget_CoreEngine::Parameters::Tracking = "Tracking";
    const String Kwidget_CoreEngine::Parameters::Cycles = "Cycles";
    const String Kwidget_CoreEngine::Parameters::Smoothing = "Smoothing";
    const String Kwidget_CoreEngine::Parameters::Sensitivity = "Sensitivity";
    const String Kwidget_CoreEngine::Parameters::ASize = "ASize";
    const String Kwidget_CoreEngine::Parameters::ARate = "ARate";
    const String Kwidget_CoreEngine::Parameters::ASpray = "ASpray";
    const String Kwidget_CoreEngine::Parameters::AMix = "AMix";
    const String Kwidget_CoreEngine::Parameters::BSize = "BSize";
    const String Kwidget_CoreEngine::Parameters::BRate = "BRate";
    const String Kwidget_CoreEngine::Parameters::BSpray = "BSpray";
    const String Kwidget_CoreEngine::Parameters::BMix = "BMix";
    const String Kwidget_CoreEngine::Parameters::Mode = "Mode";
    const String Kwidget_CoreEngine::Parameters::SamplePaths = "SamplePaths";
    const String Kwidget_CoreEngine::Parameters::TabIndex = "TabIndex";
    const String Kwidget_CoreEngine::Parameters::SlotIndex = "SlotIndex";
    const String Kwidget_CoreEngine::Parameters::Mute = "Mute";
    const String Kwidget_CoreEngine::Parameters::Solo = "Solo";
    const String Kwidget_CoreEngine::Parameters::MIDIMode = "MIDIMode";
    const String Kwidget_CoreEngine::Parameters::Distance = "Distance";
    const String Kwidget_CoreEngine::Parameters::Selections = "Selections";
 
    // These strings will be used to populate the oscillator mode combobox
    const StringArray Kwidget_CoreEngine::ModeNames = {"Sampler", "Granular", "Vehicle"};
 
    // These strings will be used to populate the MIDI trigger combobox
    const StringArray Kwidget_CoreEngine::MIDIModeNames = {
            "All Notes", "C3",  "C#3", "D3",  "D#3", "E3", "F3",  "F#3", "G3",  "G#3", "A3",  "A#3", "B3",
            "C4",        "C#4", "D4",  "D#4", "E4",  "F4", "F#4", "G4",  "G#4", "A4",  "A#4", "B4"};
 
    /*
     *   Kwidget Version History
     * 1.0 - Initial version
     * 1.1 - MIDIMode parameter changed from KParameter to CustomParameter. Additional note options added.
     */
    const String Kwidget_CoreEngine::CoreEngineVersion{"1.1"};
 
    Kwidget_CoreEngine::Kwidget_CoreEngine(const String& id) : Kwidget("CoreEngine", id)
    {
        setKwidgetVersion(CoreEngineVersion);
 
        m_soSound.canReadSpecificFiles(m_readSpecificFiles);
 
        File embeddingsFile = AssetManager::getMLEmbeddingsFile();
        if (embeddingsFile.exists())
        {
            // Initialise nearest neighbour search
            m_nearestNeighbourSearch =
                    std::make_unique<NearestNeighbourSearch>(embeddingsFile.getFullPathName().toStdString());
        }
 
        // *** Deprecated: SamplePaths & Selections are now stored in the SamplesTree
        createAndAddCustomParameter(Parameters::Selections, "");
        auto& param = *createAndAddCustomParameter(Parameters::SamplePaths, "");
        // ***
 
        // Samples Tree
        m_samplesTree = createAndAddCustomParameter<SamplesTree>(SamplesTree::Type::Samples);
 
        // Called after a user file load action (drag and drop, file browser etc) has finished
        // Initialises the SampleEngine with the loaded files and deals with any state that needs attached.
        m_samplesTree->dropCompleted = [this]() { loadFiles(m_samplesTree->getFiles()); };
 
        // Assign mute parameter to sample engine
        m_samplesTree->sampleAdded = [this](SamplesTree::Sample& newSample) {
            newSample.muteChanged = [this, &newSample]() {
                m_soSound.getSampleEngine()->setSegmentMuted(newSample.getIndex(), newSample.muteValue);
            };
        };
 
        m_samplesTree->sampleRemoved = [this](ValueTree& childWhichHasBeenRemoved, int indexFromWhichChildWasRemoved) {
            m_samplesTree->dropCompleted();
        };
 
        // SamplesPath parameter has been replaced by the SamplesTree, however this is left in for backwards
        // compatibility
        param.valueChanged = [this](const var& value) {
            auto files = StringArray::fromLines(value.toString());
 
            auto* samplesTree = getCustomParameter<SamplesTree>(SamplesTree::Type::Samples);
 
            // SamplesTree backwards compatibility
            // Parse file paths from parameter and insert into SamplesTree
            AudioFormatManager formatManager;
            formatManager.registerBasicFormats();
            for (auto file : files)
            {
                auto convertedFile = AssetManager::convertFilePath(file);
 
                File directoryPath(convertedFile);
 
                if (directoryPath.isDirectory())
                {
                    // Recursively add files from directories
                    auto foundFiles = directoryPath.findChildFiles(
                            File::findFiles, true, formatManager.getWildcardForAllFormats() + ";*" + ".kaf");
                    for (auto f : foundFiles)
                    {
                        samplesTree->updateSample(f.getFileNameWithoutExtension(), f.getFullPathName());
                    }
                }
                else
                {
                    samplesTree->updateSample(convertedFile.getFileNameWithoutExtension(), file);
                }
            }
 
            // Notify that the drop has completed, this will load the samples into the SampleEngine
            samplesTree->dropCompleted();
        }; // End SamplePaths valueChanged
 
        createAndAddCustomParameter(Parameters::TabIndex, "-1");
        createAndAddCustomParameter(Parameters::SlotIndex, "-1");
        auto midimodeParam =
                createAndAddCustomParameter(Parameters::MIDIMode, MIDIModeNames[static_cast<int>(MIDIMode::All)]);
        midimodeParam->valueChanged = [this](const var& value) {
            String newMode = value;
            m_activeMIDIMode = static_cast<MIDIMode>(MIDIModeNames.indexOf(newMode));
        };
 
        init();
 
        addParameterCallback(Parameters::Tracking, [this](float newValue) {
            m_soSound.getSampleEngine()->setTrackingValue(newValue);
            m_soSound.getSampleEngine()->setAnalysisScheme(KrotosAudioBufferDSP::AnalysisScheme::Vehicle);
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Cycles, [this](float newValue) {
            m_soSound.getSampleEngine()->setTrackingCycles(newValue);
            m_soSound.getSampleEngine()->setAnalysisScheme(KrotosAudioBufferDSP::AnalysisScheme::Vehicle);
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Mode, [this](float newValue) {
            GranularPlaybackMode activeMode = static_cast<GranularPlaybackMode>(
                    newValue * static_cast<float>(static_cast<int>(GranularPlaybackMode::NUM_MODES) - 1));
            m_soSound.getSampleEngine()->setGranularOscillatorTypeIndicator(activeMode);
        });
 
        // Add a backwards compatibility callback for the legacy MIDIMode KParameter.
        // This is only called if the incoming state is older than v1.1
        addVersionedParameterCallback("1.1", Parameters::MIDIMode, [this](float newValue) {
            const int oldNumberOfModes(5);
            MIDIMode activeMode = static_cast<MIDIMode>(newValue * static_cast<float>(oldNumberOfModes));
            setActiveMidiMode(activeMode);
        });
 
        // Broadcast message to listeners
        addParameterCallback(Parameters::Solo, [this](float newValue) {
            float muteVal = getParameter(Parameters::Mute)->get();
 
            if (newValue > ParameterManager::OnOffThreshold && m_previousSoloValue <= ParameterManager::OnOffThreshold)
            {
                soloActivate();
            }
            else if (muteVal <= ParameterManager::OnOffThreshold && newValue <= ParameterManager::OnOffThreshold &&
                     m_previousSoloValue > ParameterManager::OnOffThreshold)
            {
                soloDeActivate();
            }
 
            m_previousSoloValue = newValue;
        });
 
        addParameterCallback(Parameters::Mute, [this](float newValue) {
            float soloVal = getParameter(Parameters::Solo)->get();
            if (newValue > ParameterManager::OnOffThreshold && soloVal > ParameterManager::OnOffThreshold)
            {
                getParameter(Parameters::Solo)->set(0.0f);
            }
        });
 
        addParameterCallback(Parameters::NOR,
                             [this](float newValue) { m_enableNOR = newValue > ParameterManager::OnOffThreshold; });
 
        addParameterCallback(Parameters::Autoplay, [this](float newValue) {
            m_listeners.call(&Listener::autoPlayChanged, this, newValue);
            m_autoplayEnabled = bool(newValue > ParameterManager::OnOffThreshold);
        });
 
        addParameterCallback(Parameters::SALoop, [this](float newValue) {
            m_listeners.call(&Listener::loopEnableChanged, this, newValue);
        });
    }
 
    void Kwidget_CoreEngine::loadFiles(const StringArray& files)
    {
        m_soSound.canReadSpecificFiles(m_readSpecificFiles);
        Array<File> filesToLoad;
        try
        {
            filesToLoad = AssetManager::loadFiles(files, true, m_readSpecificFiles);
        }
        catch (EncryptedAssetException& ex)
        {
            AssetManagerUI::alertNonSubscriber();
        }
 
        if (!filesToLoad.isEmpty())
        {
            m_soSound.loadSounds(filesToLoad, false);
            refreshState();
        }
 
#if ENABLE_REFORMER
#ifdef ENABLE_COREENGINE_ANALYSIS
        // Non reformer build CoreEngine will never call Analyse
        // - in future it may have red line analysis for vehicles
        if (!filesToLoad.isEmpty()) // no need to analyse when there are no samples
        {
            m_soSound.getSampleEngine()->analyse();
        }
#endif
#endif
    }
 
    void Kwidget_CoreEngine::refreshState()
    {
        jassert(m_samplesTree);
 
        // Todo - Refactor sample engine to populate from tree so this isn't necessary.
        // Having to set the data from state after load since the samples don't exist before loadSounds is called.
        for (int i = 0; i < m_samplesTree->getParameterTree().getNumChildren(); i++)
        {
            m_soSound.getSampleEngine()->setSegmentMuted(
                    i, static_cast<bool>(m_samplesTree->getChild(i)[SamplesTree::Property::Mute]));
        }
 
        // This is a bit of a ~hack~ 'quick fix' to get the selection ranges to be set correctly.
        // Empty ranges passed into setSelectionRanges are replaced with a default range calculated from 0 to
        // segmentLength. Todo - Populate the sample engine directly from the SamplesTree
        m_soSound.getSampleEngine()->setSelectionRanges(m_samplesTree->getSampleSelections());
        // The following get ensures that the default selections are saved.
        m_samplesTree->setSampleSelections(m_soSound.getSampleEngine()->getSelectionRanges());
    }
 
    void Kwidget_CoreEngine::createNestedKwidgets(KwidgetAudioProcessor& processor)
    {
        String thisID = getKwidgetID();
 
        bool stateChanging = isStateChanging();
 
        if (getChildKwidgets().size() == 0)
        {
            // Add an ADSR for gain
            addChildKwidget(
                    processor.addChildKwidget(KwidgetFactory::KwidgetType::Adsr, thisID, "Adsr", stateChanging));
            // Connect the modulation output of ADSR1 to the gain parameter of the new Core Engine kwidget
            processor.parameterManager.addModulation(m_childKwidgets.back()->getKwidgetID(), 0, this->getKwidgetID(),
                                                     Kwidget_CoreEngine::Parameters::LevelMod, 1.0f,
                                                     KAttachment::Polarity::Unipolar);
 
            // Add an ADSR for pitch
            addChildKwidget(
                    processor.addChildKwidget(KwidgetFactory::KwidgetType::ScaledAdsr, thisID, "Adsr", stateChanging));
            // Connect the modulation output of ADSR1 to the gain parameter of the new Core Engine kwidget
            processor.parameterManager.addModulation(m_childKwidgets.back()->getKwidgetID(), 0, this->getKwidgetID(),
                                                     Kwidget_CoreEngine::Parameters::PitchMod, 1.0f,
                                                     KAttachment::Polarity::Unipolar);
        }
        else
        {
            for (auto k : m_childKwidgets)
            {
                if (k->getKwidgetType() == KwidgetFactory::KwidgetType::Adsr)
                {
                    processor.parameterManager.addModulation(k->getKwidgetID(), 0, this->getKwidgetID(),
                                                             Kwidget_CoreEngine::Parameters::LevelMod, 1.0f,
                                                             KAttachment::Polarity::Unipolar);
                }
                else if (k->getKwidgetType() == KwidgetFactory::KwidgetType::ScaledAdsr)
                {
                    processor.parameterManager.addModulation(k->getKwidgetID(), 0, this->getKwidgetID(),
                                                             Kwidget_CoreEngine::Parameters::PitchMod, 1.0f,
                                                             KAttachment::Polarity::Unipolar);
                }
            }
        }
    }
 
    bool Kwidget_CoreEngine::isMlEnabled() { return m_nearestNeighbourSearch != nullptr; }
 
    inline bool Kwidget_CoreEngine::isDroneVoice(int voiceIdx)
    {
        return (voiceIdx >= NUM_VOICES_POLY) && (voiceIdx < (NUM_VOICES_POLY + NUM_VOICES_DRONE));
    }
 
    bool Kwidget_CoreEngine::isActive(int voiceIdx)
    {
        bool activeChild = false;
        for (auto& child : this->getChildKwidgets())
        {
            if (child)
            {
                activeChild = child->isActive(voiceIdx);
                break;
            }
        }
 
        // We are only considered active if a child is active, and we are active
        return activeChild && getVoice(voiceIdx)->isActive();
    }
 
    void Kwidget_CoreEngine::noteOnInternal(int voiceIdx, int midiNote, float velocity)
    {
        midiNote &= MIDI_NOTE_MASK; // Mask out any flags - keep only the MIDI note number
        Kwidget::noteOn(voiceIdx, midiNote, velocity);
 
        for (auto& child : this->getChildKwidgets())
        {
            child->noteOn(voiceIdx, midiNote, velocity);
        }
 
        if (auto* sampleEngine = m_soSound.getSampleEngine())
        {
            m_samplesTree->setSampleIndex(sampleEngine->getNextSegmentIndex());
        }
    }
 
    void Kwidget_CoreEngine::noteOn(int voiceIdx, int midiNote, float velocity)
    {
        if (isDroneVoice(voiceIdx)) // If this is a drone voice
        {
            if (midiNote & MIDI_NOTE_FLAG_FLUSH) // and it is a 'flush' event
            {
                noteClearedInternal(voiceIdx);
            }
            else if (midiNote & MIDI_NOTE_FLAG_DRONE_NOTEUP) // and it is a 'note up' event
            {
                if (!m_autoplayEnabled) // and autoplay has been switched off
                {
                    noteOffInternal(voiceIdx, velocity);
                }
            }
            else // else this is a drone channel 'note down' event
            {
                if (m_autoplayEnabled)
                {
                    noteOnInternal(voiceIdx, midiNote, velocity);
                }
            }
        }
        else // This is a normal polyphonic note down event
        {
            if (!m_autoplayEnabled) // Only respond to notes if autoplay is off
            {
                bool noteNORFlag = static_cast<bool>(midiNote & MIDI_NOTE_FLAG_NOR);
                bool noteNORFlagMatchesMode = noteNORFlag == m_enableNOR;
                if ((m_activeMIDIMode == MIDIMode::All) && noteNORFlagMatchesMode)
                {
                    noteOnInternal(voiceIdx, midiNote, velocity);
                }
                else
                {
                    auto triggerNote = MIDI_NOTE_NUMBER_C3 + static_cast<int>(m_activeMIDIMode) - 1;
 
                    if (((midiNote & MIDI_NOTE_MASK) == triggerNote) && noteNORFlagMatchesMode)
                    {
                        noteOnInternal(voiceIdx, MIDI_NOTE_NUMBER_C3, velocity);
                    }
                }
            }
        }
    }
 
    void Kwidget_CoreEngine::noteOffInternal(int voiceIdx, float velocity)
    {
        Kwidget::noteOff(voiceIdx, velocity);
 
        for (auto& child : this->getChildKwidgets())
        {
            child->noteOff(voiceIdx, velocity);
        }
    }
 
    void Kwidget_CoreEngine::noteOff(int voiceIdx, float velocity)
    {
        if (!isDroneVoice(voiceIdx)) // If we are a drone voice, stop note can never switch us off, only startNote with
                                     // stop flag
        {
            noteOffInternal(voiceIdx, velocity);
        }
    }
 
    void Kwidget_CoreEngine::noteClearedInternal(int voiceIdx)
    {
        Kwidget::noteCleared(voiceIdx);
 
        for (auto& child : this->getChildKwidgets())
        {
            child->noteCleared(voiceIdx);
        }
    }
 
    void Kwidget_CoreEngine::noteCleared(int voiceIdx)
    {
        if (!isDroneVoice(voiceIdx)) // If we are a drone voice, stop note can never switch us off, only startNote with
                                     // stop flag
        {
            noteClearedInternal(voiceIdx);
        }
    }
 
    std::vector<Kwidget::ParameterInfo> Kwidget_CoreEngine::createParameters()
    {
        return {// NormalisableRange( rangeStart, rangeEnd, intervalValue, skewFactor, useSymmetricSkew ) // For
                // reference
                // paramID,                 paramName,                  NormalisableRange<float> range, defaultValue
                {Parameters::Start, Parameters::Start, {0.0f, 100.0f, 0.1f}, 50.0f},
                {Parameters::Size, Parameters::Size, {0.0f, 100.0f, 0.1f}, 100.0f},
                {Parameters::Rate, Parameters::Rate, {0.0f, 1000.0f, 0.001f, 0.3f}, 0.0f},
                {Parameters::Pitch, Parameters::Pitch, {-48.0f, 48.0f, 0.01f, 0.5f, true}, 0.0f},
                {Parameters::PitchMod, Parameters::PitchMod, {-48.0f, 48.0f}, 0.0f},
                {Parameters::Width, Parameters::Width, {0.0f, 1.0f, 0.001f, 0.5f}, 0.0f},
                {Parameters::Pan, Parameters::Pan, {-1.0f, 1.0f}, 0.0f},
                {Parameters::Level, Parameters::Level, {-96.0f, 12.0f, 1e-2f, DSPConstants::defaultSliderSkew}, 0.0f},
                {Parameters::SamplerLevel,
                 Parameters::SamplerLevel,
                 {-96.0f, 12.0f, 1e-2f, DSPConstants::defaultSliderSkew},
                 0.0f},
                {Parameters::GranularLevel,
                 Parameters::GranularLevel,
                 {-96.0f, 12.0f, 1e-2f, DSPConstants::defaultSliderSkew},
                 0.0f},
                {Parameters::VehicleLevel,
                 Parameters::VehicleLevel,
                 {-96.0f, 12.0f, 1e-2f, DSPConstants::defaultSliderSkew},
                 0.0f},
                {Parameters::LevelMod, Parameters::LevelMod, {0.0f, 1.0f}, 0.0f},
                {Parameters::StartRand, Parameters::StartRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::SizeRand, Parameters::SizeRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::RateRand, Parameters::RateRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::PitchRand, Parameters::PitchRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::WidthRand, Parameters::WidthRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::PanRand, Parameters::PanRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::LevelRand, Parameters::LevelRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::Quench, Parameters::Quench, {0.0f, 1.0f}, 0.0f},
                {Parameters::NOR, Parameters::NOR, {0.0f, 1.0f}, 0.0f},
                {Parameters::Robin, Parameters::Robin, {0.0f, 1.0f}, 0.0f},
                {Parameters::SALoop, Parameters::SALoop, {0.0f, 1.0f}, 0.0f},
                {Parameters::AutoRate, Parameters::AutoRate, {0.0f, 1.0f}, 0.0f},
                {Parameters::PhaseLock, Parameters::PhaseLock, {0.0f, 1.0f}, 0.0f},
                {Parameters::PhaseSync, Parameters::PhaseSync, {0.0f, 1.0f}, 0.0f},
                {Parameters::Normalise, Parameters::Normalise, {0.0f, 1.0f}, 0.0f},
                {Parameters::MuteUp, Parameters::MuteUp, {0.0f, 1.0f}, 0.0f},
                {Parameters::MuteDown, Parameters::MuteDown, {0.0f, 1.0f}, 0.0f},
                {Parameters::Autoplay, Parameters::Autoplay, {0.0f, 1.0f}, 0.0f},
                {Parameters::Shape, Parameters::Shape, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.0f},
                {Parameters::GrainMax, Parameters::GrainMax, {1.f, 400.f, 1.f, 1.0f}, 25.0f},
                {Parameters::Tracking, Parameters::Tracking, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.f},
                {Parameters::Cycles, Parameters::Cycles, {500.0f, 20000.0f, 1.0f}, 1500.0f},
                {Parameters::Smoothing, Parameters::Smoothing, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.5f},
                {Parameters::Sensitivity, Parameters::Sensitivity, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.5f},
                {Parameters::ASize, Parameters::ASize, {0.0f, 25.0f, 0.01f, 1.0f}, 5.f},
                {Parameters::ARate, Parameters::ARate, {1.0f, 100.0f, 1.0f}, 1.0f},
                {Parameters::ASpray, Parameters::ASpray, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.5f},
                {Parameters::AMix, Parameters::AMix, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.5f},
                {Parameters::BSize, Parameters::BSize, {0.0f, 25.0f, 0.01f, 1.0f}, 5.f},
                {Parameters::BRate, Parameters::BRate, {1.0f, 100.0f, 1.0f}, 1.0f},
                {Parameters::BSpray, Parameters::BSpray, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.5f},
                {Parameters::BMix, Parameters::BMix, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.5f},
                {Parameters::Mode, Parameters::Mode, {0.0f, 1.0f}, 0.0f},
                {Parameters::Mute, Parameters::Mute, {0.0f, 1.0f}, 0.0f},
                {Parameters::Solo, Parameters::Solo, {0.0f, 1.0f}, 0.0f},
                {Parameters::MIDIMode, Parameters::MIDIMode, {0.0f, 1.0f}, 0.0f},
                {Parameters::Distance, Parameters::Distance, {1.0f, 70.0f, 1.0f, 1.0f}, 1.0f}};
    }
 
    std::unique_ptr<KwidgetProcessor> Kwidget_CoreEngine::createProcessor()
    {
        return std::make_unique<KwidgetProcessor_CoreEngine>(*this, m_soSound);
    }
 
    std::unique_ptr<KwidgetGUI> Kwidget_CoreEngine::createGUI()
    {
        return std::make_unique<KwidgetGUI_CoreEngine>(*this, m_soSound);
    }
 
    String Kwidget_CoreEngine::getGuiName(int id) { return m_coreEngineGuiTypes.at(id).first; }
 
    void Kwidget_CoreEngine::addListener(Listener* listenerToAdd) { m_listeners.add(listenerToAdd); }
 
    void Kwidget_CoreEngine::removeListener(Listener* listenerToRemove)
    {
        jassert(m_listeners.contains(listenerToRemove));
        m_listeners.remove(listenerToRemove);
    }
 
    void Kwidget_CoreEngine::soloActivate()
    {
        m_listeners.call([this](Listener& l) { l.soloActivated(this); });
    }
 
    void Kwidget_CoreEngine::soloDeActivate()
    {
        m_listeners.call([this](Listener& l) { l.soloDeActivated(this); });
    }
 
    void Kwidget_CoreEngine::setActiveMidiMode(MIDIMode newMidiMode)
    {
        // update vtree state
        CustomParameter* midiParameter(getCustomParameter(Parameters::MIDIMode));
        if (midiParameter != nullptr)
        {
            midiParameter->setValue(MIDIModeNames[static_cast<int>(newMidiMode)]);
        }
 
        // set sample engine MIDI
        m_soSound.getSampleEngine()->setGranularOscillatorMIDIMode(newMidiMode);
        m_activeMIDIMode = newMidiMode;
    }
 
    MIDIMode Kwidget_CoreEngine::getActiveMidiMode() { return m_activeMIDIMode; }
} // namespace krotos