ame_Util.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ame_Math.hpp"
 
#include <array>
#include <atomic>
#include <cassert>
#include <concepts>
#include <cstddef>
#include <type_traits>
 
namespace ame
{
template <typename T>
struct Range
{
    T min;
    T Max;
    T init;
    T step;
};
 
template <std::floating_point FloatType>
constexpr FloatType addModulo2Pi (FloatType phase, FloatType increment) noexcept
{
    phase += increment;
    while (phase > twoPi<FloatType>)
    {
        phase -= twoPi<FloatType>;
    }
    return phase;
}
 
template <std::floating_point FloatType>
constexpr FloatType scale (FloatType sourceValue,
                           FloatType sourceRangeMin,
                           FloatType sourceRangeMax,
                           FloatType targetRangeMin,
                           FloatType targetRangeMax)
{
    return targetRangeMin
           + ((targetRangeMax - targetRangeMin) * (sourceValue - sourceRangeMin)) / (sourceRangeMax - sourceRangeMin);
}
 
template <std::floating_point FloatType>
class LinearSmoothedValue
{
    static_assert (! std::is_const<FloatType>::value, "FloatType is must NOT be const.");
 
public:
    LinearSmoothedValue (FloatType initialValue, const int rampSteps)
    {
        reset (initialValue);
        setRampLength (rampSteps);
    }
    ~LinearSmoothedValue() = default;
 
    bool isSmoothing() const noexcept
    {
        return countdown > 0;
    }
 
    FloatType getCurrentValue() const noexcept
    {
        return currentValue;
    }
 
    FloatType getTargetValue() const noexcept
    {
        return target;
    }
 
    void reset (FloatType newValue) noexcept
    {
        target = newValue;
        currentValue = newValue;
        countdown = 0;
    }
 
    void setRampLength (const int numSteps) noexcept
    {
        stepsToTarget = numSteps;
    }
 
    void setTargetValue (FloatType newValue) noexcept
    {
        if (newValue == target)
        {
            return;
        }
 
        if (stepsToTarget <= 0)
        {
            reset (newValue);
            return;
        }
 
        target = newValue;
        countdown = stepsToTarget;
        setStepSize();
    }
 
    FloatType getNextValue() noexcept
    {
        if (! isSmoothing())
        {
            return target;
        }
 
        --countdown;
        if (isSmoothing())
        {
            currentValue += step;
        }
        else
        {
            currentValue = target;
        }
        return currentValue;
    }
 
private:
    void setStepSize()
    {
        step = (target - currentValue) / stepsToTarget;
    }
 
    FloatType currentValue {};
    FloatType target {};
    FloatType step {};
    int countdown {};
    int stepsToTarget {};
};
 
template <std::floating_point FloatType>
class Slide
{
    static_assert (! std::is_const<FloatType>::value, "FloatType is must NOT be const.");
 
public:
    Slide() {}
    Slide (FloatType slownessOfIncrease, FloatType slownessOfDecrease) noexcept
    {
        slideUp.store (slownessOfIncrease);
        slideDown.store (slownessOfDecrease);
    }
    ~Slide() = default;
 
    void setSlownessOfIncrease (FloatType slownessIncrease)
    {
        assert (slownessIncrease >= 1.0f);
        slideUp.store (slownessIncrease);
    }
 
    void setSlownessOfDecrease (FloatType slownessDecrease)
    {
        assert (slownessDecrease >= 1.0f);
        slideDown.store (slownessDecrease);
    }
 
    FloatType process (FloatType input) noexcept
    {
        const auto dt = input - lastOutput;
        const auto s = dt > FloatType (0.0) ? slideUp.load() : slideDown.load();
        lastOutput = lastOutput + dt / s;
        return lastOutput;
    }
 
private:
    FloatType lastOutput {};
    std::atomic<FloatType> slideUp { 1.0 };
    std::atomic<FloatType> slideDown { 1.0 };
};
 
namespace
{
    template <typename T>
    concept signed_number = std::signed_integral<T> || std::floating_point<T>;
}
 
template <signed_number T>
class Wrap
{
public:
    explicit Wrap (T length) : length (length)
    {
        assert (length > 0); //length is must greater than 0
    }
 
    Wrap() = default;
    ~Wrap() = default;
 
    void set (T n)
    {
        while (n >= length)
        {
            n -= length;
        }
 
        while (n < 0)
        {
            n += length;
        }
 
        num = n;
    }
 
    [[nodiscard]] T get (T offset = 0) const noexcept
    {
        auto n = num + offset;
        while (n >= length)
        {
            n -= length;
        }
 
        while (n < 0)
        {
            n += length;
        }
        return n;
    }
 
    void changeLength (T newLength) noexcept
    {
        length = newLength;
    }
 
    [[nodiscard]] T getLength() const noexcept
    {
        return length;
    }
 
    T operator++() noexcept
    {
        ++num;
        if (num >= length)
        {
            num = 0;
        }
        return num;
    }
 
    T operator++ (int) noexcept
    {
        num++;
        if (num >= length)
        {
            num = 0;
        }
        return num;
    }
 
    T operator+= (T add) noexcept
    {
        num += add;
        while (num >= length)
        {
            num -= length;
        }
        return num;
    }
 
private:
    T num {};
    T length {};
};
 
template <typename... Ts>
constexpr std::array<std::byte, sizeof...(Ts)> makeBytes (Ts&&... args) noexcept
{
    return { std::byte (std::forward<Ts> (args))... };
}
} // namespace ame