Math.hpp

[詳解]

//
//    数学定数、関数
//
//    Copyright (c) 2022 udonrobo
//
 
#pragma once
 
#include <math.h>
#include <Udon/Types/Range.hpp>
 
#ifdef abs
#   undef abs
 
template <typename T>
inline constexpr T abs(const T& rhs)
{
    return rhs < 0 ? -rhs : rhs;
}
 
#endif
 
namespace Udon
{

    constexpr double Pi       = 3.1415926535897932384626433832795;      // std::numbers::pi_v<double>       (C++20)

    constexpr double HalfPi   = 1.5707963267948966192313216916398;      // std::numbers::pi_v<double> / 2   (C++20)

    constexpr double TwoPi    = 6.283185307179586476925286766559;       // std::numbers::pi_v<double> * 2   (C++20)

    constexpr double DegToRad = 0.017453292519943295769236907684886;    // std::numbers::pi_v<double> / 180 (C++20)

    constexpr double RadToDeg = 57.295779513082320876798154814105;      // 180 / std::numbers::pi_v<double> (C++20)
 
};    // namespace Udon
 
namespace Udon
{

    template <typename A, typename B>
    inline constexpr auto
    Min(const A& lhs, const B& rhs) -> decltype(lhs, rhs)
    {
        return lhs < rhs ? lhs : rhs;
    }

    template <typename A, typename B>
    inline constexpr auto
    Max(const A& lhs, const B& rhs) -> decltype(lhs, rhs)
    {
        return lhs > rhs ? lhs : rhs;
    }

    template <typename A, typename B, typename C>
    inline constexpr A
    Constrain(const A& amt, const B& low, const C& high)
    {
        return Min(Max(amt, low), high);
    }

    template <typename A, typename B, typename C = B>
    inline constexpr A
    Constrain(const A& amt, const Udon::Range<B, C>& range)
    {
        return Min(Max(amt, range.min), range.max);
    }

    template <typename T>
    inline constexpr T
    ToRadians(const T& rhs)
    {
        return rhs * DegToRad;
    }

    template <typename T>
    inline constexpr T
    ToDegrees(const T& rhs)
    {
        return rhs * RadToDeg;
    }

    template <typename T>
    inline constexpr T
    Abs(const T& rhs)
    {
        return rhs < 0 ? -rhs : rhs;
    }

    template <typename T>
    inline constexpr T
    Sq(const T& x)
    {
        return x * x;
    }

    inline constexpr int
    Floor(double x)
    {
        return x - (int)x < 0 ? (int)x - 1 : (int)x;
    }

    inline constexpr int
    Round(double x)
    {
        return x - (int)x >= 0.5 ? (int)x + 1 : (int)x;
    }

    inline constexpr int
    Ceil(double x)
    {
        return x - (int)x > 0 ? (int)x + 1 : (int)x;
    }

    inline constexpr double
    Map(const double value, const double inputMin, const double inputMax, const double outputMin, const double outputMax)
    {
        return (value - inputMin) * (outputMax - outputMin) / (inputMax - inputMin) + outputMin;
    }
 
    // inline bool
    // FloatEq(const double l, const double r)
    // {
    //     return 
    // }

    inline double
    Normalized(double value, double min, double max)
    {
        const auto cycle = max - min;
 
        const auto modValue = fmod((value - min), cycle) + min;
 
        if (modValue < min)
        {
            return modValue + cycle;
        }
        else
        {
            return modValue;
        }
    }

    inline double
    Hypotenuse(double x, double y)
    {
        return sqrt(x * x + y * y);
    }
 
}    // namespace Udon