animatedValue.h

/*
    Copyright (c) 2019-2023 Brett g Porter
 
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
*/
#pragma once
 
namespace friz
{
 
class AnimatedValue
{
public:
    AnimatedValue (float startVal_, float endVal_)
    : startVal { startVal_ }
    , endVal { endVal_ }
    , currentVal { startVal_ } {
 
    };
 
    virtual ~AnimatedValue () = default;
 
    virtual float getNextValue (int msElapsed, int msSinceLastUpdate) = 0;
 
    float getEndValue () const { return endVal; }
 
    virtual bool isFinished () = 0;
 
    virtual bool updateTarget (float /*newValue*/) { return false; }
 
    void cancel (bool moveToEndPosition)
    {
        if (!canceled)
        {
            canceled = true;
            doCancel (moveToEndPosition);
        }
    }
 
private:
    virtual void doCancel (bool moveToEndPosition)
    {
        if (moveToEndPosition)
            currentVal = endVal;
    }
 
protected:
    float startVal;
    float endVal;
    float currentVal;
 
    bool canceled { false };
    bool finished { false };
};
 
class ToleranceValue : public AnimatedValue
{
public:
    ToleranceValue (float startVal, float endVal, float tolerance)
    : AnimatedValue { startVal, endVal }
    , tolerance { tolerance }
    {
    }
 
    float getNextValue (int /*msElapsed*/, int msSinceLastUpdate) override
    {
        jassert (msSinceLastUpdate >= 0);
        if (msSinceLastUpdate == 0)
            return currentVal;
 
        for (int i { 0 }; i < msSinceLastUpdate; ++i)
        {
            currentVal = snapToEnd (generateNextValue ());
            if (isFinished ())
                break;
        }
 
        return currentVal;
    }
 
    bool isFinished () override
    {
        // we are finished in either of these cases:
        // 1. user/code canceled us
        // 2. current value is within tolerance of the end value.
        return (finished || canceled);
    }
 
private:
    float snapToEnd (float val)
    {
        if (std::fabs (val - endVal) < tolerance)
        {
            finished = true;
            return endVal;
        }
        return val;
    }
 
    virtual float generateNextValue () = 0;
 
protected:
    float tolerance;
};
 
class TimedValue : public AnimatedValue
{
public:
    TimedValue (float startVal, float endVal, int duration_)
    : AnimatedValue { startVal, endVal }
    , duration { duration_ }
    {
    }
 
    float getNextValue (int msElapsed, int /* msSinceLastUpdate*/) override
    {
        if (msElapsed >= duration)
        {
            finished   = true;
            currentVal = endVal;
            return currentVal;
        }
        float progress { static_cast<float> (msElapsed) / duration };
        return generateNextValue (progress);
    }
 
    bool isFinished () override { return finished; }
 
protected:
    float scale (float curvePoint) { return startVal + curvePoint * (endVal - startVal); }
 
private:
    virtual float generateNextValue (float progress) = 0;
 
protected:
    int duration;
};
 
// GCC doesn't support some functions that are specified in the standard:
// std::sinf / cosf/ powf/ etc. (see
// https://stackoverflow.com/questions/56417980/cosf-sinf-etc-are-not-in-std).
// We define a few inline utility functions to narrow the return type of
// the double-returning sin/cos/pow functions to float as we prefer here.
// Thanks to [Sudara](https://github.com/sudara) for catching this.
 
inline float sin_f (float v)
{
    return static_cast<float> (std::sin (v));
}
 
inline float cos_f (float v)
{
    return static_cast<float> (std::cos (v));
}
 
inline float pow_f (float v, float pow)
{
    return static_cast<float> (std::pow (v, pow));
}
 
} // namespace friz