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 = initValue;
                mValue = initValue;
                mDestination = initValue;
            }
            
            void setStepCount(int stepCount) { mStepCount = stepCount; }
            
            void setValue(const T& destination) { mNewDestination = destination; }
            
            T getNextValue()
            {
                if (mNewDestination != mDestination)
                {
                    mDestination = mNewDestination;
                    mStepCounter = mStepCount;
                    if (mStepCounter == 0)
                        mValue = mDestination;
                    else
                        mIncrement = (mDestination - mValue) / T(mStepCount);
                }
                
                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; }
            
            inline bool isRamping() const { return mStepCounter > 0 || mDestination != mNewDestination; }
        
        private:
            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.
            int mStepCount = 0; // Number of steps in the ramp.
            int mStepCounter = 0; // Current step index, 0 means at destination
        };
        
        
    }
}