Kwidget_Reformer.cpp

Go to the documentation of this file.

namespace krotos
{
    const String Kwidget_Reformer::Version = "1";
 
    const String Kwidget_Reformer::Parameters::Start = "Start";
    const String Kwidget_Reformer::Parameters::PuckX = "PuckX";
    const String Kwidget_Reformer::Parameters::PuckY = "PuckY";
    const String Kwidget_Reformer::Parameters::Nearest = "Nearest";
    const String Kwidget_Reformer::Parameters::Size = "Size";
    const String Kwidget_Reformer::Parameters::Rate = "Rate";
    const String Kwidget_Reformer::Parameters::Pitch = "Pitch";
    const String Kwidget_Reformer::Parameters::PitchMod = "PitchMod";
    const String Kwidget_Reformer::Parameters::Width = "Width";
    const String Kwidget_Reformer::Parameters::Pan = "Pan";
    const String Kwidget_Reformer::Parameters::Level = "Level";
    const String Kwidget_Reformer::Parameters::GranularLevel = "GranularLevel";
    const String Kwidget_Reformer::Parameters::LevelMod = "LevelMod";
    const String Kwidget_Reformer::Parameters::StartRand = "StartRand";
    const String Kwidget_Reformer::Parameters::SizeRand = "SizeRand";
    const String Kwidget_Reformer::Parameters::RateRand = "RateRand";
    const String Kwidget_Reformer::Parameters::PitchRand = "PitchRand";
    const String Kwidget_Reformer::Parameters::WidthRand = "WidthRand";
    const String Kwidget_Reformer::Parameters::PanRand = "PanRand";
    const String Kwidget_Reformer::Parameters::LevelRand = "LevelRand";
    const String Kwidget_Reformer::Parameters::Popcorn = "Popcorn";
    const String Kwidget_Reformer::Parameters::Proximity = "Proximity";
    const String Kwidget_Reformer::Parameters::Radius = "Radius";
    const String Kwidget_Reformer::Parameters::Quench = "Quench";
    const String Kwidget_Reformer::Parameters::Robin = "Robin";
    const String Kwidget_Reformer::Parameters::SALoop = "SALoop";
    const String Kwidget_Reformer::Parameters::Normalise = "Normalise";
    const String Kwidget_Reformer::Parameters::Autoplay = "Autoplay";
    const String Kwidget_Reformer::Parameters::Shape = "Shape";
    const String Kwidget_Reformer::Parameters::GrainMax = "GrainMax";
    const String Kwidget_Reformer::Parameters::Segmentation = "Segmentation";
    const String Kwidget_Reformer::Parameters::FeatureExtr = "FeatureExtr";
    const String Kwidget_Reformer::Parameters::SamplePaths = "SamplePaths";
    const String Kwidget_Reformer::Parameters::TabIndex = "TabIndex";
    const String Kwidget_Reformer::Parameters::SlotIndex = "SlotIndex";
    const String Kwidget_Reformer::Parameters::Mute = "Mute";
    const String Kwidget_Reformer::Parameters::Solo = "Solo";
    const String Kwidget_Reformer::Parameters::MIDIMode = "MIDIMode";
    const String Kwidget_Reformer::Parameters::Tracking = "Tracking";
    const String Kwidget_Reformer::Parameters::Coeff0 = "Coeff0";
    const String Kwidget_Reformer::Parameters::Coeff1 = "Coeff1";
    const String Kwidget_Reformer::Parameters::Coeff2 = "Coeff2";
    const String Kwidget_Reformer::Parameters::Coeff3 = "Coeff3";
    const String Kwidget_Reformer::Parameters::Coeff4 = "Coeff4";
    const String Kwidget_Reformer::Parameters::Coeff5 = "Coeff5";
    const String Kwidget_Reformer::Parameters::Coeff6 = "Coeff6";
    const String Kwidget_Reformer::Parameters::Coeff7 = "Coeff7";
    const String Kwidget_Reformer::Parameters::SelectX = "SelectX";
    const String Kwidget_Reformer::Parameters::SelectY = "SelectY";
    const String Kwidget_Reformer::Parameters::SelectZ = "SelectZ";
 
    const String Kwidget_Reformer::Parameters::AAlpha = "AAlpha";
    const String Kwidget_Reformer::Parameters::AH = "AH";
    const String Kwidget_Reformer::Parameters::AA = "AA";
 
    // These strings will be used to populate the oscillator mode combobox
    const StringArray Kwidget_Reformer::ModeNames = {"Sampler", "Granular", "Vehicle"};
 
    // Note: changing the value of MaxSegmentationMethods breaks backwards compatibility
    const int Kwidget_Reformer::MaxSegmentationMethods = 129;
    const std::map<int, String> Kwidget_Reformer::SegmentationMethods = {
            {0, "No Segmentation"},
            //{1, "New Segmentation Method"}, // add new method in a free slot
            {32, "Texture Mode | Complex Audio Textures [Beta]"},
            {64, "Beats Mode | Percussive Sounds [Beta]"},
            {96, "Texture Mode | Complex Audio Textures"},
            {128, "Chords Mode | Delicate Nuanced Sounds [Beta]"}};
 
    // Note: changing the value of MaxFeatureExtrMethods breaks backwards compatibility
    const int Kwidget_Reformer::MaxFeatureExtrMethods = 193;
    const std::map<int, String> Kwidget_Reformer::FeatureExtrMethods = {
            {0, "No Analysis"},
            {1, "HarmonicPitchEstimation"}, // add new method in a free slot
            {32, "MFCC/PCA [Beta]"},
            {64, "Centroid/Level"},
            {96, "SpectralCentroid/RMS [Beta]"},
            {128, "SpectralFlatness/RMS [Beta]"},
            {160, "erbCentroid/RMS [Beta]"},
            {192, "erbCentroid/erbFlatness [Beta]"}};
 
    // These strings will be used to populate the MIDI trigger combobox
    const StringArray Kwidget_Reformer::MIDIModeNames = {"All Notes", "C3", "C#3", "D3", "D#3", "E3"};
 
    Kwidget_Reformer::Kwidget_Reformer(const String& id) : Kwidget("Reformer", id)
    {
        m_soSound.canReadSpecificFiles(m_readSpecificFiles);
 
        // ** Deprecated - SamplePaths are now stored in the SamplesTree. This is retained for backwards compatibility.
        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);
            };
        };
 
        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();
        };
 
        createAndAddCustomParameter(Parameters::TabIndex, "-1");
        createAndAddCustomParameter(Parameters::SlotIndex, "-1");
 
        init();
 
        addParameterCallback(Parameters::Tracking, [this](float newValue) {
            m_soSound.getSampleEngine()->setTrackingValue(newValue);
            m_soSound.getSampleEngine()->setTrackingCycles(1.f);
            m_soSound.getSampleEngine()->getAnalysisCoefficients().tracking = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff0, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff0 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff1, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff1 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff2, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff2 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff3, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff3 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff4, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff4 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff5, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff5 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff6, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff6 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::Coeff7, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().coeff7 = newValue;
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::SelectX, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().selectX = newValue;
            m_soSound.getSampleEngine()->triggerDisplayUpdate();
        });
 
        addParameterCallback(Parameters::SelectY, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().selectY = newValue;
            m_soSound.getSampleEngine()->triggerDisplayUpdate();
        });
 
        addParameterCallback(Parameters::SelectZ, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().selectZ = newValue;
            m_soSound.getSampleEngine()->triggerDisplayUpdate();
        });
 
        addParameterCallback(Parameters::AAlpha, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().dispAAlpha = newValue / 255.f;
            m_soSound.getSampleEngine()->triggerDisplayCacheRegeneration();
            m_soSound.getSampleEngine()->triggerDisplayUpdate();
        });
 
        addParameterCallback(Parameters::AH, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().dispAH = newValue / 255.f;
            m_soSound.getSampleEngine()->triggerDisplayCacheRegeneration();
            m_soSound.getSampleEngine()->triggerDisplayUpdate();
        });
 
        addParameterCallback(Parameters::AA, [this](float newValue) {
            m_soSound.getSampleEngine()->getAnalysisCoefficients().dispAA = newValue / 255.f;
            m_soSound.getSampleEngine()->triggerDisplayCacheRegeneration();
            m_soSound.getSampleEngine()->triggerDisplayUpdate();
        });
 
        addParameterCallback(Parameters::Segmentation, [this](float newValue) {
            KrotosAudioBufferDSP::SegmentationMethod segmentation =
                    static_cast<KrotosAudioBufferDSP::SegmentationMethod>(
                            newValue *
                            static_cast<float>(
                                    static_cast<int>(KrotosAudioBufferDSP::SegmentationMethod::NUM_SEGMENTATIONS) - 1));
            m_soSound.getSampleEngine()->setSegmentationMethod(segmentation);
            m_soSound.getSampleEngine()->setAnalysisScheme(KrotosAudioBufferDSP::AnalysisScheme::GeneralScheme);
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::FeatureExtr, [this](float newValue) {
            KrotosAudioBufferDSP::FeatureExtrMethod featureExtraction =
                    static_cast<KrotosAudioBufferDSP::FeatureExtrMethod>(
                            newValue *
                            static_cast<float>(
                                    static_cast<int>(KrotosAudioBufferDSP::FeatureExtrMethod::NUM_FEATUREMETHODS) - 1));
 
            m_soSound.getSampleEngine()->setFeatureExtrMethod(featureExtraction);
            m_soSound.getSampleEngine()->setAnalysisScheme(KrotosAudioBufferDSP::AnalysisScheme::GeneralScheme);
            m_soSound.getSampleEngine()->analyse();
        });
 
        addParameterCallback(Parameters::MIDIMode, [this](float newValue) {
            MIDIMode activeMode =
                    static_cast<MIDIMode>(newValue * static_cast<float>(static_cast<int>(MIDIMode::NUM_MODES) - 1));
            m_soSound.getSampleEngine()->setGranularOscillatorMIDIMode(activeMode);
            m_activeMIDIMode = activeMode;
        });
 
        addParameterCallback(Parameters::Solo, [this](float newValue) {
            float muteVal = getParameter(Parameters::Mute)->get();
 
            if (newValue > ParameterManager::OnOffThreshold && m_soloValue <= ParameterManager::OnOffThreshold)
            {
                soloActivate();
            }
            else if (muteVal <= ParameterManager::OnOffThreshold && newValue <= ParameterManager::OnOffThreshold &&
                     m_soloValue > ParameterManager::OnOffThreshold)
            {
                soloDeActivate();
            }
 
            m_soloValue = newValue;
        });
 
        addParameterCallback(Parameters::Mute, [this](float newValue) {
            float soloVal = getParameter("Solo")->get();
            if (newValue == 1.0f && soloVal == 1.0f)
            {
                getParameter("Solo")->set(0.0f);
            }
        });
 
        addParameterCallback(Parameters::Autoplay, [this](float newValue) {
            m_listeners.call(&Listener::autoPlayChanged, this, newValue);
            m_autoplayEnabled = bool(newValue > 0.5f);
        });
 
        addParameterCallback(Parameters::SALoop, [this](float newValue) {
            m_listeners.call(&Listener::loopEnableChanged, this, newValue);
        });
    }
 
    void Kwidget_Reformer::loadFiles(const StringArray& files)
    {
        m_soSound.canReadSpecificFiles(m_readSpecificFiles);
        bool tweakRequested = false;
 
        Array<File> filesToLoad;
 
        try
        {
            filesToLoad = AssetManager::loadFiles(files, true, m_readSpecificFiles); // Converts into array of full
            // paths appropriate to platform
        }
        catch (EncryptedAssetException& ex)
        {
            // TODO: This causes multiple popups, should be elevated to state loading
            AssetManagerUI::alertNonSubscriber();
        }
 
        if (!filesToLoad.isEmpty())
        {
            m_soSound.loadSounds(filesToLoad, tweakRequested);
        }
 
        // By the time we get here, the KrotosAudioBufferDSP contained deep with m_soSound will have lost any
        // state which was set via parameter listener callbacks, so we call notifyAllParametersListeners() to
        // make all of our parameters re-send their values
        notifyAllParametersListeners();
 
        updateSamplesTree();
 
        if (files.isEmpty()) // no need to analyse when there are no samples
        {
            m_soSound.getSampleEngine()->setAnalysisScheme(KrotosAudioBufferDSP::AnalysisScheme::GeneralScheme);
            m_soSound.getSampleEngine()->analyse();
        }
    }
 
    void Kwidget_Reformer::updateSamplesTree()
    {
        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_Reformer::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
            // Reformer kwidget
            processor.parameterManager.addModulation(m_childKwidgets.back()->getKwidgetID(), 0, this->getKwidgetID(),
                                                     Kwidget_Reformer::Parameters::LevelMod, 1.0f,
                                                     KAttachment::Polarity::Unipolar);
        }
        else
        {
            // there should only be 1 kwidgets in here.
            jassert(m_childKwidgets.size() == 1);
            for (auto k : m_childKwidgets)
            {
                if (k->getKwidgetType() == KwidgetFactory::KwidgetType::Adsr)
                {
                    processor.parameterManager.addModulation(k->getKwidgetID(), 0, this->getKwidgetID(),
                                                             Kwidget_Reformer::Parameters::LevelMod, 1.0f,
                                                             KAttachment::Polarity::Unipolar);
                }
            }
        }
    }
 
    bool Kwidget_Reformer::isUCSEnabled() { return m_categorySearch != nullptr; }
 
    inline bool Kwidget_Reformer::isDroneVoice(int voiceIdx)
    {
        return (voiceIdx >= NUM_VOICES_POLY) && (voiceIdx < (NUM_VOICES_POLY + NUM_VOICES_DRONE));
    }
 
    bool Kwidget_Reformer::isActive(int voiceIdx)
    {
        bool activeChild = false;
        for (auto& child : this->getChildKwidgets())
        {
            if (child->isActive(voiceIdx))
            {
                activeChild = true;
                break;
            }
        }
 
        // We are only considered active if a child is active, and we are active
        return activeChild && getVoice(voiceIdx)->isActive();
    }
 
    void Kwidget_Reformer::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);
        }
    }
 
    void Kwidget_Reformer::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_Reformer::noteOffInternal(int voiceIdx, float velocity)
    {
        Kwidget::noteOff(voiceIdx, velocity);
 
        for (auto& child : this->getChildKwidgets())
        {
            child->noteOff(voiceIdx, velocity);
        }
    }
 
    void Kwidget_Reformer::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_Reformer::noteClearedInternal(int voiceIdx)
    {
        Kwidget::noteCleared(voiceIdx);
 
        for (auto& child : this->getChildKwidgets())
        {
            child->noteCleared(voiceIdx);
        }
    }
 
    void Kwidget_Reformer::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_Reformer::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}, 2.8f},
                {Parameters::PuckX, Parameters::PuckX, {0.0f, 1.0f, 0.001f}, 0.5f},
                {Parameters::PuckY, Parameters::PuckY, {0.0f, 1.0f, 0.001f}, 0.5f},
                {Parameters::Nearest, Parameters::Nearest, {1.f, 1000.f, 1.f, 1.0f}, 9.0f},
                {Parameters::Size, Parameters::Size, {0.0f, 1600.0f, 0.1f}, 50.0f},
                {Parameters::Rate, Parameters::Rate, {0.0f, 1000.0f, 0.001f, 0.3f}, 21.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}, 1.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::GranularLevel,
                 Parameters::GranularLevel,
                 {-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.11f},
                {Parameters::SizeRand, Parameters::SizeRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.14f},
                {Parameters::RateRand, Parameters::RateRand, {0.0f, 1.0f, 0.000001f, 1.0f}, 0.4f},
                {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::Popcorn, Parameters::Popcorn, {0.0f, 1.0f}, 1.0f},
                {Parameters::Proximity, Parameters::Proximity, {0.0f, 1.0f}, 0.0f},
                {Parameters::Radius, Parameters::Radius, {0.0f, 0.5f, 0.001f, 1.0f}, 0.1f},
                {Parameters::Quench, Parameters::Quench, {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::Normalise, Parameters::Normalise, {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}, 1.0f},
                {Parameters::GrainMax, Parameters::GrainMax, {1.f, 400.f, 1.f, 1.0f}, 25.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::Segmentation, Parameters::Segmentation, {0.0f, 1.0f}, 0.75f},
                {Parameters::FeatureExtr, Parameters::FeatureExtr, {0.0f, 1.0f}, 0.333333333333333f},
                {Parameters::Tracking, Parameters::Tracking, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff0, Parameters::Coeff0, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff1, Parameters::Coeff1, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff2, Parameters::Coeff2, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff3, Parameters::Coeff3, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff4, Parameters::Coeff4, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff5, Parameters::Coeff5, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff6, Parameters::Coeff6, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::Coeff7, Parameters::Coeff7, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::SelectX, Parameters::SelectX, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::SelectY, Parameters::SelectY, {0.0f, 1.0f, 0.001f, 1.0f}, 0.5f},
                {Parameters::SelectZ, Parameters::SelectZ, {0.0f, 1.0f, 0.001f, 1.0f}, 1.f},
 
                {Parameters::AAlpha, Parameters::AAlpha, {0.0f, 255.0f, 1.0f, 1.0f}, 0.f},
                {Parameters::AH, Parameters::AH, {0.0f, 255.0f, 1.0f, 1.0f}, 0.f},
                {Parameters::AA, Parameters::AA, {0.0f, 255.0f, 1.0f, 1.0f}, 0.f},
        };
    }
 
    std::unique_ptr<KwidgetProcessor> Kwidget_Reformer::createProcessor()
    {
        return std::make_unique<KwidgetProcessor_Reformer>(*this, m_soSound);
    }
 
    std::unique_ptr<KwidgetGUI> Kwidget_Reformer::createGUI()
    {
        return std::make_unique<KwidgetGUI_Reformer>(*this, m_soSound);
    }
 
    String Kwidget_Reformer::getGuiName(int id) { return m_reformerGuiTypes.at(id).first; }
 
    void Kwidget_Reformer::addListener(Listener* listenerToAdd) { m_listeners.add(listenerToAdd); }
 
    void Kwidget_Reformer::removeListener(Listener* listenerToRemove)
    {
        jassert(m_listeners.contains(listenerToRemove));
        m_listeners.remove(listenerToRemove);
    }
 
    void Kwidget_Reformer::soloActivate()
    {
        m_listeners.call([this](Listener& l) { l.soloActivated(this); });
    }
 
    void Kwidget_Reformer::soloDeActivate()
    {
        m_listeners.call([this](Listener& l) { l.soloDeActivated(this); });
    }
} // namespace krotos