KwidgetProcessor_XyPad.cpp

Go to the documentation of this file.

namespace krotos
{
    KwidgetProcessor_XyPad::KwidgetProcessor_XyPad(Kwidget& owner)
        : KwidgetProcessor(owner), m_mode(CurveMode::Exponential)
    {
        auto currentMode = dynamic_cast<Kwidget_XyPad*>(&getOwner())->getCurrentMode();
        // number of modulators determmined from the xyMode
        int numModulators;
 
        std::shared_ptr<KParameter> param;
 
        switch (currentMode)
        {
        case Kwidget_XyPad::xyMode::Simple: {
            numModulators = 2;
            m_paramValues.resize(static_cast<size_t>(numModulators));
            // for the two position parameters
            for (int i = 0; i < numModulators; i++)
            {
                m_paramValues[static_cast<size_t>(i)] = 0.0f;
                addModulator(false);
                getModulator(i)->setValues(&(m_paramValues[static_cast<size_t>(i)]), 1);
                (i == 0) ? param = getOwner().getParameterToAttach(Parameters::posX)
                         : param = getOwner().getParameterToAttach(Parameters::posY);
 
                m_listenerObjects.add(new KParameter::AudioListenerObject(param, [=](float x) {
                    m_paramValues[static_cast<size_t>(i)] = x;
                    getModulator(i)->callListeners();
                }));
            }
            break;
        }
        case Kwidget_XyPad::xyMode::Peak: {
            // Get KParameter pointers to set the callbacks when their values change
            auto paramX = getOwner().getParameterToAttach(Parameters::posX);
            auto paramY = getOwner().getParameterToAttach(Parameters::posY);
            numModulators = 4;
            m_paramValues.resize(2);
 
            for (int i = 0; i < numModulators; i++)
            {
                // Add 4  slow Modulators
                addModulator(false);
            }
 
            // Initialize vector of the 2 parameter values
            for (int i = 0; i < m_paramValues.size(); i++)
            {
                // first address is held for posX param and second for posY.
                m_paramValues[static_cast<size_t>(i)] = 0.0f;
                // Each modulators float* points to the vector of the two param values.
                getModulator(i)->setValues(&(m_paramValues[i]), 1);
                getModulator(i + 2)->setValues(&(m_paramValues[i]), 1);
                // Assign mappingFunction to modulators 2 and 3 to map incoming data to curves.
                getModulator(i + 2)->mappingFunctionPtr = m_mode == CurveMode::Exponential ? &mapToCurve : &mapToLine;
            }
 
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramX, [=](float x) {
                // position 0 is pointing to the posX param
                m_paramValues[static_cast<size_t>(posX)] = x;
                getModulator(posX)->callListeners();
                getModulator(posX2)->callListeners();
            }));
 
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramY, [=](float y) {
                // position 1 is pointing to the posY param
                m_paramValues[static_cast<size_t>(posY)] = y;
                getModulator(posY)->callListeners();
                getModulator(posY2)->callListeners();
            }));
            break;
        }
        case Kwidget_XyPad::xyMode::FourZone: {
            // Get KParameter pointers to set the callbacks when their values change
            auto paramY = getOwner().getParameterToAttach(Parameters::posY);
            auto paramX = getOwner().getParameterToAttach(Parameters::posX);
            numModulators = 4;
            m_paramValues.resize(2);
 
            // Initialize vector of the 2 parameter values
            for (int i = 0; i < m_paramValues.size(); i++)
            {
                // first address is held for posX param and second for posY.
                m_paramValues[static_cast<size_t>(i)] = 0.0f;
            }
 
            for (int i = 0; i < numModulators; i++)
            {
                // Add 4  slow Modulators
                addModulator(false);
                // Each modulators float* points to the vector of the two param values.
                getModulator(i)->setValues(&(m_paramValues[0]), 2);
            }
 
            // Assign mappingFunction to each modulator from TopLeft to BottomRight corner
            // TODO: have an array of function pointers. this way you could map infinite function pointer mappings.
            getModulator(0)->mappingFunctionPtr = &mapToDistanceTL;
            getModulator(1)->mappingFunctionPtr = &mapToDistanceTR;
            getModulator(2)->mappingFunctionPtr = &mapToDistanceBL;
            getModulator(3)->mappingFunctionPtr = &mapToDistanceBR;
 
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramX, [=](float x) {
                // position 0 is pointing to the posX param
                m_paramValues[static_cast<size_t>(0)] = x;
 
                for (int i = 0; i < numModulators; i++)
                {
                    getModulator(i)->callListeners();
                }
            }));
 
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramY, [=](float y) {
                // position 1 is pointing to the posY param
                m_paramValues[static_cast<size_t>(1)] = y;
 
                for (int i = 0; i < numModulators; i++)
                {
                    getModulator(i)->callListeners();
                }
            }));
            break;
        }
        case Kwidget_XyPad::xyMode::Distance: {
            // Get KParameter pointers to set the callbacks when their values change
            auto paramX = getOwner().getParameterToAttach(Parameters::posX);
            auto paramY = getOwner().getParameterToAttach(Parameters::posY);
            numModulators = 4;
            m_paramValues.resize(2);
 
            // Initialize vector of the 2 parameter values
            for (int i = 0; i < m_paramValues.size(); i++)
            {
                // first address is held for posX param and second for posY.
                m_paramValues[static_cast<size_t>(i)] = 0.0f;
            }
 
            for (int i = 0; i < numModulators; i++)
            {
                // Add 4  slow Modulators
                addModulator(false);
                // Each modulators float* points to the vector of the two param values.
                getModulator(i)->setValues(&(m_paramValues[0]), 2);
            }
 
            // Assign mappingFunction to each modulator from TopLeft to BottomRight corner
            // TODO: have an array of function pointers. this way you could map infinite function pointer mappings.
            getModulator(1)->mappingFunctionPtr = &mapToDistDecreasing;
            getModulator(2)->mappingFunctionPtr = &mapToDistBranched;
            getModulator(3)->mappingFunctionPtr = &mapToDistIncreasing;
 
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramX, [=](float x) {
                // position 0 is pointing to the posX param
                m_paramValues[static_cast<size_t>(0)] = x;
 
                for (int i = 0; i < numModulators; i++)
                {
                    getModulator(i)->callListeners();
                }
            }));
 
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramY, [=](float y) {
                // position 1 is pointing to the posY param
                m_paramValues[static_cast<size_t>(1)] = y;
 
                for (int i = 0; i < numModulators; i++)
                {
                    getModulator(i)->callListeners();
                }
            }));
            break;
        }
        case Kwidget_XyPad::xyMode::Polar:
        {
            numModulators = 4;
            m_paramValues.resize(static_cast<size_t>(numModulators));
            //Get KParameter pointers to set the callbacks when their values change
            auto paramX = getOwner().getParameterToAttach(Parameters::posX);
            auto paramY = getOwner().getParameterToAttach(Parameters::posY);
            //Initialize vector of the 2 parameter values
            for (int i = 0; i < m_paramValues.size(); i++)
            {
                //first address is held for posX param and second for posY.
                m_paramValues[static_cast<size_t>(i)] = 0.0f;
            }
            for (int i = 0; i < numModulators; i++)
            {
                //Add 4 slow Modulators
                addModulator(false);
            }
            // Set modulator values and mapping functions
            getModulator(0)->setValues(&m_paramValues[0], 1); // x-linear
            getModulator(1)->setValues(&m_paramValues[1], 1); // y-linear
            getModulator(2)->setValues(&m_paramValues[0], 2); // Distance Decreasing
            getModulator(2)->mappingFunctionPtr = &mapToRadiusDecreasing;
            getModulator(3)->setValues(&m_paramValues[0], 2); // Distance Increasing
            getModulator(3)->mappingFunctionPtr = &mapToRadiusIncreasing;
 
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramX, [=](float x) {
                // position 0 is pointing to the posX param
                m_paramValues[static_cast<size_t>(0)] = x;
                getModulator(0)->callListeners();
                getModulator(2)->callListeners();
                getModulator(3)->callListeners();
            }));
            m_listenerObjects.add(new KParameter::AudioListenerObject(paramY, [=](float y) {
                // position 1 is pointing to the posY param
                m_paramValues[static_cast<size_t>(1)] = y;
                // only the first - seoncd modulators (distance) should be called here
                getModulator(1)->callListeners();
                getModulator(2)->callListeners();
                getModulator(3)->callListeners();
            }));
            break;
        }
        }
 
        auto paramX = getOwner().getParameterToAttach(Parameters::posX);
        auto paramY = getOwner().getParameterToAttach(Parameters::posY);
        m_listenerObjects.add(new KParameter::AudioListenerObject(paramX, [=](float x) { m_puckX.setInput(x); }));
 
        m_listenerObjects.add(new KParameter::AudioListenerObject(paramY, [=](float y) { m_puckY.setInput(y); }));
 
        m_indexOfVelocityModulator = getNumModulators();
        addModulator(true);
    }
 
    void KwidgetProcessor_XyPad::prepare(double sampleRate, int samplesPerBlock)
    {
        //added calls to update any listeners of the modulators
        getOwner()
                .getParameter(Parameters::posX)
                ->sendValueChangedMessageToListeners(getOwner().getParameterToAttach(Parameters::posX)->getValue());
        getOwner()
                .getParameter(Parameters::posY)
                ->sendValueChangedMessageToListeners(getOwner().getParameterToAttach(Parameters::posY)->getValue());
 
        m_sampleRate = sampleRate;
        m_samplesPerBlock = samplesPerBlock;
 
        m_puckX.prepare(sampleRate, samplesPerBlock);
        m_puckY.prepare(sampleRate, samplesPerBlock);
 
        m_buffer.setSize(1, samplesPerBlock);
 
        getModulator(m_indexOfVelocityModulator)->setValues(m_buffer.getReadPointer(0), samplesPerBlock);
    }
 
    void KwidgetProcessor_XyPad::process(AudioBuffer<float>& buffer)
    {
        auto numSamples = buffer.getNumSamples();
        auto bufferPtr = m_buffer.getWritePointer(0);
 
        m_puckX.process();
        m_puckY.process();
 
        nextBlock(numSamples);
 
        for (int i = 0; i < numSamples; i++)
        {
            nextSample();
            bufferPtr[i] = Point<float>(m_puckX.getOutput(), m_puckY.getOutput()).getDistanceFromOrigin();
        }
    }
 
    float KwidgetProcessor_XyPad::mapToCurve(const float* incomingValues, const float depth)
    {
        // calculate parameters of equation y = ax^2 + bx + c
        float c = 1.0f - depth;
        float a = (c - 1.0f) / 0.25f;
        float b = -1.0f * a;
        // calculate the mapped value on that equation
        float mappedValue = a * powf(incomingValues[0], 2.0f) + b * incomingValues[0] + c;
 
        return mappedValue;
    }
 
    float KwidgetProcessor_XyPad::mapToLine(const float* incomingValues, const float depth)
    {
        float max = 1.0f;
        // minimum values are determined by the depth parameter.
        float min = 1.0f - depth;
 
        if (incomingValues[0] <= 0.5f)
        {
            // calculate the gradient of the line for 0<=x<=0.5
            float lamda = (max - min) / 0.5f;
            // insert input parameter x to the line equation
            float mappedValue = lamda * incomingValues[0] + min;
            return mappedValue;
        }
        else
        {
            // calculate the gradient of the line for 0.5<x<=1
            float lamda = (min - max) / 0.5f;
            float mappedValue = lamda * incomingValues[0] + (max + depth);
            return mappedValue;
        }
    }
 
    const Point<float> KwidgetProcessor_XyPad::m_topLeft{0.f, 1.f};
    const Point<float> KwidgetProcessor_XyPad::m_topRight{1.f, 1.f};
    const Point<float> KwidgetProcessor_XyPad::m_bottomLeft{0.f, 0.f};
    const Point<float> KwidgetProcessor_XyPad::m_bottomRight{1.f, 0.f};
    const Point<float> KwidgetProcessor_XyPad::m_centre{0.5f, 0.5f};
    const float KwidgetProcessor_XyPad::m_topYCoordinate{1.f};
 
    float KwidgetProcessor_XyPad::constPower(float val)
    {
        // return(sqrtf(val));                               // Sqrt equal power crossfading
        return sinf(val * MathConstants<float>::halfPi); // Sine law equal power crossfading
    }
 
    float KwidgetProcessor_XyPad::attenuationCurve(float val) { return std::sqrtf(std::abs(1.0f - (2.0f * val))); }
 
    float KwidgetProcessor_XyPad::increaseCurve(float val) { return std::sqrtf(std::abs((2.0f * val) - 1.0f)); }
 
    float KwidgetProcessor_XyPad::distanceYTop(const float* incomingValues)
    {
        // Calculate the distance to top Y
        float puckY{incomingValues[1]};
        return jmin<float>(std::abs(1.0f - puckY), 1.f); // Clamp to 1
    }
 
    float KwidgetProcessor_XyPad::mapToDistance(const float* incomingValues, const float depth,
                                                const Point<float> corner)
    {
        // Calculate the distance to the supplied corner
        Point<float> puckVector{incomingValues[0], incomingValues[1]};
        float distanceToCorner = jmin<float>(puckVector.getDistanceFrom(corner), 1.f); // Clamp to 1
 
        // We are now in gain space, so do the scaling
        float modulationValue = constPower(1.f - distanceToCorner * depth);
 
        return modulationValue;
    }
 
    float KwidgetProcessor_XyPad::mapToDistanceTL(const float* incomingValues, const float depth)
    {
        return mapToDistance(incomingValues, depth, m_topLeft);
    }
 
    float KwidgetProcessor_XyPad::mapToDistanceTR(const float* incomingValues, const float depth)
    {
        return mapToDistance(incomingValues, depth, m_topRight);
    }
 
    float KwidgetProcessor_XyPad::mapToDistanceBL(const float* incomingValues, const float depth)
    {
        return mapToDistance(incomingValues, depth, m_bottomLeft);
    }
 
    float KwidgetProcessor_XyPad::mapToDistanceBR(const float* incomingValues, const float depth)
    {
        return mapToDistance(incomingValues, depth, m_bottomRight);
    }
 
    float KwidgetProcessor_XyPad::mapToDistDecreasing(const float* incomingValues, const float depth)
    {
        // Calculate the distance to top Y
        float distanceToTop = distanceYTop(incomingValues);
 
        // We are now in gain space, so do the scaling
        float modulationValue;
        if (0.0f <= distanceToTop && distanceToTop <= 0.5f)
            modulationValue = attenuationCurve(distanceToTop * depth);
        else
            modulationValue = 1.0f - depth;
 
        return modulationValue;
    }
 
    float KwidgetProcessor_XyPad::mapToDistBranched(const float* incomingValues, const float depth)
    {
        // Calculate the distance to top Y
        float distanceToTop = distanceYTop(incomingValues);
 
        // Two branch function
        float modulationValue;
        if (0.0f <= distanceToTop && distanceToTop <= 0.5f)
        {
            // shift to negative axis (from 0<=x<=0.5 to -0.5<=x<=0)
            distanceToTop -= 0.5f;
            modulationValue = std::sqrtf(std::abs(1.0f + 2.0f * distanceToTop * depth));
        }
        else
        {
            //(from 0.5 <x <= 1 to  0<x<=0.5)
            distanceToTop -= 0.5f;
            modulationValue = std::sqrtf(std::abs(1.0f - (2.0f * distanceToTop * depth)));
        }
 
        return modulationValue;
    }
 
    float KwidgetProcessor_XyPad::mapToDistIncreasing(const float* incomingValues, const float depth)
    {
        // Calculate the distance to top Y
        float puckY{incomingValues[1]};
        float distanceToTop = jmin<float>(std::abs(1.0f - puckY), 1.f); // Clamp to 1
 
        // We are now in gain space, so do the scaling
        // Two branch function
        float modulationValue;
        if (0.0f <= distanceToTop && distanceToTop < 0.5f)
            modulationValue = 1.0f - depth;
        else
            modulationValue = increaseCurve(distanceToTop * depth);
 
        return modulationValue;
    }
 
    float KwidgetProcessor_XyPad::mapToRadiusDecreasing(const float* incomingValues, const float depth)
    {
        // Cartesian to polar radius conversion - distance from centre
        Point<float> puckVector{incomingValues[0], incomingValues[1]};
        float distanceToCentre = jmin<float>(puckVector.getDistanceFrom(m_centre), 1.f); // Clamp to 1
        // Normalize
        distanceToCentre /= m_cntrDiag;
        float modValue = /*constPower */ (1.f - distanceToCentre * depth); // TODO: See how it behaved with constPower
 
        return modValue;
    }
 
    float KwidgetProcessor_XyPad::mapToRadiusIncreasing(const float* incomingValues, const float depth)
    {
        // Cartesian to polar radius conversion - distance from centre
        Point<float> puckVector{incomingValues[0], incomingValues[1]};
        float distanceToCentre = jmin<float>(puckVector.getDistanceFrom(m_centre), 1.f); // Clamp to 1
        // Normalize
        distanceToCentre /= m_cntrDiag;
        // Calculate the modulation factor using linear interpolation between 1 and distanceToCentre
        float modValue = 1.0f + depth * (distanceToCentre - 1.0f);
 
        return modValue;
    }
} // namespace krotos