linearsmoothedvalue.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Nap includes
#include <nap/signalslot.h>
 
namespace nap
{
    namespace audio
    {
        
        template<typename T>
        class LinearSmoothedValue
        {
        public:
        
        public:
            LinearSmoothedValue(const T& initValue, int stepCount) : mNewDestination(initValue), mValue(initValue), mDestination(initValue), mStepCount(stepCount)
            {
            }
 
            void reset(const T& initValue)
            {
                mNewDestination.store(initValue);
                mValue = initValue;
                mDestination = initValue;
            }
            
            void setStepCount(int stepCount) { mStepCount.store(stepCount); }
            
            void setValue(const T& destination) { mNewDestination.store(destination); }
            
            T getNextValue()
            {
                T newDestination = mNewDestination.load();
                int stepCount = mStepCount.load();
                
                if (newDestination != mDestination)
                {
                    mDestination = newDestination;
                    mStepCounter = stepCount;
                    if (mStepCounter == 0)
                        mValue = mDestination;
                    else
                        mIncrement = (mDestination - mValue) / T(stepCount);
                }
                
                if (mStepCounter > 0)
                {
                    mValue = mValue + mIncrement;
                    mStepCounter--;
                    if (mStepCounter == 0)
                        mValue = mDestination;
                }
                
                return mValue;
            }
            
            inline T getValue() const { return mValue; }
            
            inline T getDestination() const { return mNewDestination.load(); }
            
            inline bool isRamping() const { return mStepCounter > 0 || mDestination != mNewDestination.load(); }
        
        private:
            std::atomic<T> mNewDestination = 0;
            
            T mValue; // Value that is being controlled by this object.
            T mIncrement; // Increment value per step of the current ramp when mode is linear.
            T mDestination = 0; // Destination value of the current ramp.
            std::atomic<int> mStepCount = 0; // Number of steps in the ramp.
            int mStepCounter = 0; // Current step index, 0 means at destination
        };
        
        
    }
}