KAttachment.h

Go to the documentation of this file.

namespace krotos
{
    //==============================================================================
    class KAttachment : public AudioProcessorParameter::Listener, public Modulator::Listener
    {
      public:
        class ParameterUpdater
        {
          public:
            ParameterUpdater(KAttachment& owner) : m_owner(owner), m_updateCounter(0), m_sampleCounter(0) {}
 
            void next()
            {
                // Update parameter if the update counter resets to 0
                if (m_updateCounter == 0)
                    callUpdateFunction();
 
                incrementCounters();
            }
 
            void reset()
            {
                m_updateCounter = 0;
                m_sampleCounter = 0;
            }
 
          private:
            void callUpdateFunction()
            {
                auto bufferPtr = m_owner.m_valueBuffer.getWritePointer(0);
                m_owner.m_updateFunction(bufferPtr[m_sampleCounter]);
            }
 
            void incrementCounters()
            {
                m_updateCounter = (m_updateCounter + 1) % m_owner.m_updateRate;
                ++m_sampleCounter;
            }
 
            KAttachment& m_owner;
            int m_updateCounter;
            int m_sampleCounter;
        };
 
        KAttachment(std::shared_ptr<KParameter> paramToAttach, std::function<void(float)> updateFunction = nullptr);
 
        KAttachment(std::shared_ptr<KParameter> paramToAttach, float smoothingTimeSeconds, int updateRate,
                    std::function<void(float)> updateFunction = nullptr);
 
        ~KAttachment() override;
 
        void prepare(double sampleRate, int samplesPerBlock);
 
        bool nextBlock(int numSamples);
 
        const float* data();
 
        bool needsUpdate() const;
 
        ParameterUpdater* getUpdater();
 
        enum Polarity
        {
            Bipolar,
            Unipolar
        };
 
        void addModulator(Modulator* m, float depth = 1.0f, Polarity polarity = Polarity::Bipolar);
 
        void removeModulator(Modulator* m);
 
        void setModulatorDepth(Modulator* m, float depth);
 
        void setModulatorPolarity(Modulator* m, Polarity polarity);
 
        void applyPendingUpdates();
 
      private:
        friend class ParameterUpdater;
 
        enum Mode
        {
            Discrete,
            Continuous
        };
 
        void parameterValueChanged(int /*paramIndex*/, float newValue) override;
        void parameterGestureChanged(int, bool) override {}
        void sendInitialUpdate();
        void modulatorChanged(const Modulator* m) override;
        void updateSmoother();
 
        std::weak_ptr<RangedAudioParameter> const m_parameterPtr;
        RangedAudioParameter* m_cachedParameterPtr;
        float m_parameterValue;
        AudioBuffer<float> m_valueBuffer;
        const Mode m_attachmentMode;
        std::unique_ptr<ParameterUpdater> m_updater;
 
        SmoothedValue<float> m_smoother{0.0f};
        float m_smoothingTimeSeconds;
        int m_numSmoothingSamples{0};
 
        Array<Modulator*> m_slowModulators;
        Array<Modulator*> m_fastModulators;
 
        struct Depth
        {
            float value;
            Polarity polarity;
        };
 
        std::map<Modulator*, Depth> m_depthMap;
 
        double m_sampleRate{0.0};
        int m_maxBlockSize{0};
 
        bool m_needsUpdate{false};
        bool m_wasSmoothing{false};
        const std::function<void(float)> m_updateFunction;
        int m_updateRate{0};
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(KAttachment)
    };
} // namespace krotos