export module Core.Math;

import Core.Meta;

export namespace Core {
    template<typename T>
    T interpolate(const T& a, const T& b, float f) {
        return a * (1.0f - f) + b * f;
    }

    constexpr bool isPowerOf2(int i) {
        return (i & (i - 1)) == 0;
    }

    template<typename T>
    constexpr T roundUpLog2(T i) {
        if(i <= 0) {
            return 0;
        }
        T c = 1;
        while(((i - 1) >> c) > 0) {
            c++;
        }
        return c;
    }

    template<typename T>
    constexpr const T& min(const T& t) {
        return t;
    }

    template<typename T, typename... Args>
    constexpr const T& min(const T& t, Args&&... args) {
        const T& o = min(Core::forward<Args>(args)...);
        return t < o ? t : o;
    }

    template<typename T>
    constexpr const T& max(const T& t) {
        return t;
    }

    template<typename T, typename... Args>
    constexpr const T& max(const T& t, Args&&... args) {
        const T& o = max(Core::forward<Args>(args)...);
        return o < t ? t : o;
    }

    template<typename T>
    constexpr const T& clamp(const T& t, const T& borderA, const T& borderB) {
        const T& low = min(borderA, borderB);
        const T& high = max(borderA, borderB);
        return max(low, min(high, t));
    }

    inline constexpr float PI = 3.14159265358979323846f;

    template<typename T>
    constexpr T radianToDegree(const T& radians) {
        return radians * static_cast<T>(180.0f / PI);
    }

    template<typename T>
    constexpr T degreeToRadian(const T& radians) {
        return radians * static_cast<T>(PI / 180.0f);
    }
}