KAttachment.cpp

Go to the documentation of this file.

namespace krotos
{
    KAttachment::KAttachment(std::shared_ptr<KParameter> paramToAttach, std::function<void(float)> updateFunction)
        : m_parameterPtr(paramToAttach), m_parameterValue(paramToAttach->getValue()), m_attachmentMode(Mode::Discrete),
          m_updater(nullptr), m_smoothingTimeSeconds(0.0f), m_updateFunction(std::move(updateFunction))
    {
        jassert(paramToAttach != nullptr);
 
        if (auto parameter = m_parameterPtr.lock())
        {
            parameter->addListener(this);
            m_cachedParameterPtr = parameter.get();
        }
    }
 
    KAttachment::KAttachment(std::shared_ptr<KParameter> paramToAttach, float smoothingTimeSeconds, int updateRate,
                             std::function<void(float)> updateFunction)
        : m_parameterPtr(paramToAttach), m_parameterValue(paramToAttach->getValue()),
          m_attachmentMode(Mode::Continuous), m_updater(new ParameterUpdater(*this)),
          m_smoothingTimeSeconds(smoothingTimeSeconds), m_updateFunction(std::move(updateFunction)),
          m_updateRate(updateRate)
    {
        jassert(paramToAttach != nullptr);
 
        if (smoothingTimeSeconds <= 0.0f)
        {
            // Continuous parameter attachments must satisfy the above condition.
            // If you want a discrete parameter, use the discrete constructor.
            jassertfalse;
            m_smoothingTimeSeconds = 2e-2f;
        }
 
        if (updateFunction != nullptr && updateRate <= 0)
        {
            // If you are using the KAttachment's updater, then you must use a valid update rate.
            jassertfalse;
            updateRate = 1;
        }
        if (auto parameter = m_parameterPtr.lock())
        {
            parameter->addListener(this);
        }
    }
 
    KAttachment::~KAttachment()
    {
        if (auto parameter = m_parameterPtr.lock())
        {
            parameter->removeListener(this);
        }
    }
 
    void KAttachment::prepare(double sampleRate, int samplesPerBlock)
    {
        m_sampleRate = sampleRate;
        m_maxBlockSize = samplesPerBlock;
        m_valueBuffer.setSize(1, m_maxBlockSize);
 
        auto numSmoothingSamples = static_cast<int>(m_sampleRate * m_smoothingTimeSeconds);
 
        // if no smoothing is desired, the smoother is set to 1 sample
        if (numSmoothingSamples == 0)
            m_numSmoothingSamples = 1;
        else
            m_numSmoothingSamples = jmax<int>(numSmoothingSamples, samplesPerBlock);
 
        m_smoother.reset(m_numSmoothingSamples);
        if (auto parameter = m_parameterPtr.lock())
        {
            parameterValueChanged(0, parameter->getValue());
            m_cachedParameterPtr = parameter.get();
        }
        sendInitialUpdate();
    }
 
    bool KAttachment::nextBlock(int numSamples)
    {
        // You must call prepare() first!
        jassert(m_sampleRate > 0.0);
 
        if (m_attachmentMode == Mode::Discrete)
        {
            if (m_smoother.isSmoothing())
            {
                // Update the parameter buffer
                auto bufferPtr = m_valueBuffer.getWritePointer(0);
                auto newValue = m_cachedParameterPtr->convertFrom0to1(m_smoother.getNextValue());
                for (int i = 0; i < numSamples; i++)
                    bufferPtr[i] = newValue;
 
                // Update the audio processor
                if (m_updateFunction != nullptr)
                    m_updateFunction(newValue);
            }
 
            return false;
        }
        else
        {
            // Once the smoother is done smoothing, the parameter value buffer is updated for
            // one more block to ensure that all changes are flushed to the processor.
            if (!m_fastModulators.isEmpty() || m_smoother.isSmoothing())
            {
                m_wasSmoothing = true;
                m_needsUpdate = true;
            }
            else if (!m_smoother.isSmoothing() && m_wasSmoothing)
            {
                m_wasSmoothing = false;
                m_needsUpdate = true;
            }
            else
            {
                m_needsUpdate = false;
                return false;
            }
 
            // Fill buffer with output of smoother
            auto bufferPtr = m_valueBuffer.getWritePointer(0);
            for (int i = 0; i < numSamples; i++)
                bufferPtr[i] = m_smoother.getNextValue();
 
            // Add modulation output to the buffer
            for (auto modulator : m_fastModulators)
            {
                auto d = m_depthMap.at(modulator);
                auto depth = d.value;
                bool isBipolar = d.polarity == Polarity::Bipolar;
                auto modValues = modulator->getValues();
 
                for (int i = 0; i < numSamples; i++)
                {
                    // Calculate the modulation value and add it to the parameter value.
                    // For bipolar modulation, rescale the modulation value from [0.0, 1.0] to [-1.0, 1.0]
                    // and halve the depth factor.
                    bufferPtr[i] += isBipolar ? ((modValues[i] * 2.0f) - 1.0f) * (depth * 0.5f) : modValues[i] * depth;
                }
            }
 
            // Denormalize the buffer to get the actual parameter values
            for (int i = 0; i < numSamples; i++)
                bufferPtr[i] = m_cachedParameterPtr->convertFrom0to1(bufferPtr[i]);
 
            // Reset the ParameterUpdater
            if (needsUpdate())
            {
                m_updater->reset();
                return true;
            }
 
            return false;
        }
    }
 
    const float* KAttachment::data() { return m_valueBuffer.getReadPointer(0); }
 
    KAttachment::ParameterUpdater* KAttachment::getUpdater()
    {
        // You have to check for an active updater before calling this function,
        // either with needsUpdate() or the return value of nextBlock()
        jassert(needsUpdate());
 
        return m_updater.get();
    }
 
    void KAttachment::addModulator(Modulator* m, float depth, Polarity polarity)
    {
        if (m->isFast())
        {
            m_fastModulators.add(m);
            m->addListener(this);
        }
        else
        {
            m_slowModulators.add(m);
            m->addListener(this);
        }
 
        struct Depth d = {depth, polarity};
        m_depthMap.emplace(m, d);
    }
 
    void KAttachment::removeModulator(Modulator* m)
    {
        m_fastModulators.removeFirstMatchingValue(m);
        m_slowModulators.removeFirstMatchingValue(m);
        m->removeListener(this);
 
        m_depthMap.erase(m);
 
        // reset parameter to value without the modulation
        parameterValueChanged(0, m_parameterValue);
    }
 
    void KAttachment::setModulatorDepth(Modulator* m, float depth)
    {
        jassert(m_depthMap.count(m) == 1);
        jassert(depth >= -1.0f && depth <= 1.0f);
 
        m_depthMap[m].value = depth;
        modulatorChanged(m);
    }
 
    void KAttachment::setModulatorPolarity(Modulator* m, Polarity polarity)
    {
        jassert(m_depthMap.count(m) == 1);
 
        m_depthMap[m].polarity = polarity;
        modulatorChanged(m);
    }
 
    void KAttachment::applyPendingUpdates()
    {
        if (m_smoother.isSmoothing())
            sendInitialUpdate();
    }
 
    bool KAttachment::needsUpdate() const { return m_needsUpdate && m_updateFunction != nullptr; }
 
    void KAttachment::parameterValueChanged(int /*paramIndex*/, float newValue)
    {
        m_parameterValue = newValue;
        updateSmoother();
    }
 
    void KAttachment::sendInitialUpdate()
    {
        // Initialize the smoother with the current parameter value
        auto currentVal = m_smoother.getTargetValue();
        m_smoother.setCurrentAndTargetValue(currentVal);
 
        // Update all the values in the buffer to match the current parameter value
        auto val = m_cachedParameterPtr->convertFrom0to1(currentVal);
        auto bufferPtr = m_valueBuffer.getWritePointer(0);
        for (int i = 0; i < m_valueBuffer.getNumSamples(); i++)
            bufferPtr[i] = val;
 
        // Update the audio processor
        if (m_updateFunction != nullptr)
            m_updateFunction(val);
    }
 
    void KAttachment::modulatorChanged(const Modulator* m)
    {
        if (!m->isFast())
            updateSmoother();
    }
 
    void KAttachment::updateSmoother()
    {
        float value = m_parameterValue;
 
        for (auto& modulator : m_slowModulators)
        {
            // if the modulator has a mapping function, the mapping function determines the output - No polarity.
            if (modulator->mappingFunctionPtr != nullptr)
            {
                // Pointer to the vector of parameter values this modulator is connected to eg. XY
                auto incomingParamValues = modulator->getValues();
                auto depth = m_depthMap.at(modulator).value;
 
                //check for special case of gain parameter
                if (m_cachedParameterPtr->getNormalisableRange().getRange().getStart() <= -60.0f)
                {
                    // Convert dB space into gain space
                    auto parameterValuedB = m_cachedParameterPtr->convertFrom0to1(value);
                    auto parameterValueGain = Decibels::decibelsToGain(
                            parameterValuedB, m_cachedParameterPtr->getNormalisableRange().getRange().getStart());
 
                    // We are now in gain space, so do the scaling
                    parameterValueGain *= modulator->mappingFunctionPtr(incomingParamValues, depth);
 
                    // Convert result from gain space back into dB space
                    parameterValuedB = Decibels::gainToDecibels(
                            parameterValueGain, m_cachedParameterPtr->getNormalisableRange().getRange().getStart());
                    value = m_cachedParameterPtr->convertTo0to1(parameterValuedB);
                }
                else
                {
                    value *= modulator->mappingFunctionPtr(incomingParamValues, depth);
                }
            }
            else // modulator has no mapping function
            {
                auto d = m_depthMap.at(modulator);
                bool isBipolar = d.polarity == Polarity::Bipolar;
                auto depth = d.value;
 
                // Calculate the modulation value and add it to the parameter value.
                // For bipolar modulation, rescale the modulation value from [0.0, 1.0] to [-1.0, 1.0]
                // and halve the depth factor.
                auto valueIncoming = modulator->getValues()[0];
                auto modulationValue =
                        isBipolar ? ((valueIncoming * 2.0f) - 1.0f) * (depth * 0.5f) : valueIncoming * depth;
                value += modulationValue;
            }
        }
 
        m_smoother.setTargetValue(value);
    }
} // namespace krotos