Math.hpp

#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Types/Math/Vector.hpp>
 
#include <cmath>
 
namespace Infinity::Types::Math
{
    constexpr float PI = 3.14159265358979323846f;
    constexpr float TWO_PI = 6.28318530717958647692f;
    constexpr float HALF_PI = 1.57079632679489661923f;
    constexpr float INV_PI = 0.31830988618379067154f;
    
    constexpr double PI_D = 3.14159265358979323846;
    constexpr double TWO_PI_D = 6.28318530717958647692;
    constexpr double HALF_PI_D = 1.57079632679489661923;
    constexpr double INV_PI_D = 0.31830988618379067154;
 
    constexpr inline float radians(float degrees)
    {
        return degrees * (PI / 180.0f);
    }
 
    constexpr inline double radians(double degrees)
    {
        return degrees * (PI_D / 180.0);
    }
 
    constexpr inline float degrees(float radians)
    {
        return radians * (180.0f / PI);
    }
 
    constexpr inline double degrees(double radians)
    {
        return radians * (180.0 / PI_D);
    }
 
    inline float normalizeAngle(float angle)
    {
        angle = std::fmod(angle + PI, TWO_PI);
        if (angle < 0.0f)
            angle += TWO_PI;
        return angle - PI;
    }
 
    inline double normalizeAngle(double angle)
    {
        angle = std::fmod(angle + PI_D, TWO_PI_D);
        if (angle < 0.0)
            angle += TWO_PI_D;
        return angle - PI_D;
    }
 
    inline float normalizeAngleDegrees(float angle)
    {
        angle = std::fmod(angle + 180.0f, 360.0f);
        if (angle < 0.0f)
            angle += 360.0f;
        return angle - 180.0f;
    }
 
    inline double normalizeAngleDegrees(double angle)
    {
        angle = std::fmod(angle + 180.0, 360.0);
        if (angle < 0.0)
            angle += 360.0;
        return angle - 180.0;
    }
 
    Vector3 INFINITY_API_PUBLIC lerp(const Vector3& a, const Vector3& b, float t);
 
    Vector3 INFINITY_API_PUBLIC mix(const Vector3& a, const Vector3& b, float t);
 
    Vector3 INFINITY_API_PUBLIC quatToEuler(Quaternion quat);
 
    Quaternion INFINITY_API_PUBLIC eulerToQuat(Vector3 euler);
    
    float INFINITY_API_PUBLIC smoothstep(float s1, float s2, float val);
}