KwidgetProcessor.cpp

Go to the documentation of this file.

namespace krotos
{
    KwidgetProcessor::KwidgetProcessor(Kwidget& owner) : m_owner(owner) {}
 
    void KwidgetProcessor::prepareToPlay(double sampleRate, int samplePerBlock)
    {
        prepare(sampleRate, samplePerBlock);
 
        // TODO: add the ability to select number of output & input channels
        const int numIns = 2;
        const int numOuts = 2;
        setPlayConfigDetails(numIns, numOuts, sampleRate, samplePerBlock);
 
        for (auto& attachment : m_attachments)
            attachment->prepare(sampleRate, samplePerBlock);
    }
 
    void KwidgetProcessor::processBlock(AudioBuffer<float>& buffer, MidiBuffer&) { process(buffer); }
 
    void KwidgetProcessor::noteOn(int midiNoteNumber, float velocity, int) { ignoreUnused(midiNoteNumber, velocity); }
 
    void KwidgetProcessor::noteOff(float velocity) { ignoreUnused(velocity); }
 
    bool KwidgetProcessor::isActive() { return false; }
 
    std::shared_ptr<KAttachment> KwidgetProcessor::getAttachment(const String& paramID)
    {
        jassert(m_attachmentMap.count(paramID) == 1);
        return m_attachmentMap.at(paramID);
    }
 
    int KwidgetProcessor::getNumModulators() const { return m_modulators.size(); }
 
    Modulator* KwidgetProcessor::getModulator(int index)
    {
        jassert(isPositiveAndBelow(index, m_modulators.size()));
        return m_modulators.getUnchecked(index);
    }
 
    const String& KwidgetProcessor::getKwidgetType() const { return m_owner.getKwidgetType(); }
 
    const String& KwidgetProcessor::getKwidgetID() const { return m_owner.getKwidgetID(); }
 
    void KwidgetProcessor::updateAttachments()
    {
        for (auto att : m_attachments)
            att->applyPendingUpdates();
    }
 
    void KwidgetProcessor::nextBlock(int numSamples)
    {
        m_activeUpdaters.resize(0);
 
        for (auto& attachment : m_attachments)
            if (attachment->nextBlock(numSamples))
                m_activeUpdaters.push_back(attachment->getUpdater());
    }
 
    void KwidgetProcessor::nextSample()
    {
        for (auto& updater : m_activeUpdaters)
            updater->next();
    }
 
    void KwidgetProcessor::addParameterAttachments(std::vector<AttachmentInfo> attachments)
    {
        for (auto& att : attachments)
        {
            jassert((att.updateRate == -1 && att.updateFunction == nullptr) || att.updateFunction != nullptr);
 
            // gets parameter object
            auto param = m_owner.getParameterToAttach(att.paramID);
 
            // pointer is passed to attachment object
 
            if (att.updateRate == 0)
                m_attachments.push_back(std::make_shared<KAttachment>(param, std::move(att.updateFunction)));
            else
                m_attachments.push_back(std::make_shared<KAttachment>(param, static_cast<float>(m_smoothingTimeSeconds),
                                                                      att.updateRate, std::move(att.updateFunction)));
 
            m_attachmentMap[att.paramID] = m_attachments.back();
        }
    }
 
    void KwidgetProcessor::addParameterCallback(const String& paramID, std::function<void(float)> callback)
    {
        m_parameterCallbacks.add(
                new KParameter::AudioListenerObject(m_owner.getParameterToAttach(paramID), std::move(callback)));
    }
} // namespace krotos