mathutils.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// External Includes
#include <glm/glm.hpp>
#include <nap/numeric.h>
#include <limits>
#include <utility/dllexport.h>
#include <algorithm>
#include <string>
 
namespace nap
{
    namespace math
    {
        inline constexpr double E           = 2.71828182845904523536;   // e
        inline constexpr double LOG2E       = 1.44269504088896340736;   // log2(e)
        inline constexpr double LOG10E      = 0.434294481903251827651;  // log10(e)
        inline constexpr double LN2         = 0.693147180559945309417;  // ln(2)
        inline constexpr double LN10        = 2.30258509299404568402;   // ln(10)
        inline constexpr double PI          = 3.14159265358979323846;   // pi
        inline constexpr double PIX2        = 6.28318530717958647692;   // pi*2
        inline constexpr double PI_2        = 1.57079632679489661923;   // pi/2
        inline constexpr double PI_4        = 0.785398163397448309616;  // pi/4
        inline constexpr double M1_PI       = 0.318309886183790671538;  // 1/pi
        inline constexpr double M2_PI       = 0.636619772367581343076;  // 2/pi
        inline constexpr double M2_SQRTPI   = 1.12837916709551257390;   // 2/sqrt(pi)
        inline constexpr double SQRT2       = 1.41421356237309504880;   // sqrt(2)
        inline constexpr double SQRT1_2     = 0.707106781186547524401;  // 1/sqrt(2)
 
        inline constexpr glm::vec3 X_AXIS   = { 1.0f, 0.0f, 0.0f };
        inline constexpr glm::vec3 Y_AXIS   = { 0.0f, 1.0f, 0.0f };
        inline constexpr glm::vec3 Z_AXIS   = { 0.0f, 0.0f, 1.0f };
        inline constexpr glm::vec3 FORWARD  = { 0.0f, 0.0f, -1.0f };
 
        template<typename T>
        T fit(T value, T min, T max, T outMin, T outMax);
 
        template<typename T>
        T lerp(const T& start, const T& end, float percent);
 
        template<typename T>
        T clamp(T value, T min, T max);
 
        template<typename T>
        T min(T left, T right);
 
        template<typename T>
        T max(T left, T right);
 
        template<typename T>
        T floor(T value);
 
        template<typename T>
        T ceil(T value);
 
        template<typename T>
        T power(T value, T exp);
 
        template<typename T>
        T smoothStep(T value, T edge0, T edge1);
 
        template<typename T>
        T abs(T value);
 
        template<typename T>
        T constexpr epsilon();
 
        template<typename T>
        T constexpr max();
        
        template<typename T>
        T constexpr min();
 
        template<typename T>
        T sign(T value);
 
        template<typename T>
        T bell(T time, T strength);
 
        template<typename T>
        T random(T min, T max);
 
        void NAPAPI setRandomSeed(int value);
 
        template<typename T>
        T NAPAPI smoothDamp(T currentValue, T targetValue, T& currentVelocity, float deltaTime, float smoothTime, float maxSpeed = math::max<float>());
 
        template<typename T>
        void NAPAPI smooth(T& currentValue, const T& targetValue, T& currentVelocity, float deltaTime, float smoothTime, float maxSpeed);
 
        glm::mat4 NAPAPI composeMatrix(const glm::vec3& translate, const glm::quat& rotate, const glm::vec3& scale);
 
        glm::quat NAPAPI eulerToQuat(const glm::vec3& eulerAngle);
 
        glm::quat NAPAPI eulerToQuat(float roll, float pitch, float yaw);
 
        glm::vec3 NAPAPI radians(const glm::vec3& eulerDegrees);
 
        glm::vec3 NAPAPI radians(float roll, float pitch, float yaw);
 
        float NAPAPI radians(float degrees);
 
        float NAPAPI degrees(float radians);
 
        glm::vec3 NAPAPI extractPosition(const glm::mat4x4& matrix);
 
        glm::vec3 NAPAPI objectToWorld(const glm::vec3& point, const glm::mat4x4& objectToWorldMatrix);
 
        glm::vec3 NAPAPI worldToObject(const glm::vec3& point, const glm::mat4x4& objectToWorldMatrix);
 
        std::string NAPAPI generateUUID();
 
        // Template definitions
 
        template<typename T>
        T fit(T value, T min, T max, T outMin, T outMax)
        {
            T v = glm::clamp<T>(value, min, max);
            T m = max - min;
            m = (m == 0.0f) ? std::numeric_limits<T>::epsilon() : m;
            return (v - min) / (m) * (outMax - outMin) + outMin;
        }
 
        template<typename T>
        T clamp(T value, T min, T max)
        {
            return glm::clamp<T>(value, min, max);
        }
 
        template<typename T>
        T min(T left, T right)
        {
            return std::min<T>(left, right);
        }
 
        template<typename T>
        T max(T left, T right)
        {
            return std::max<T>(left, right);
        }
 
        template<typename T>
        T floor(T value)
        {
            return glm::floor(value);
        }
 
        template<typename T>
        T ceil(T value)
        {
            return glm::ceil(value);
        }
 
        template<typename T>
        T constexpr epsilon()
        {
            return std::numeric_limits<T>::epsilon();
        }
 
        template<typename T>
        T constexpr max()
        {
            return std::numeric_limits<T>::max();
        }
 
        template<typename T>
        T constexpr min()
        {
            return std::numeric_limits<T>::lowest();
        }
 
        template<typename T>
        T sign(T value)
        {
            return static_cast<T>(value == 0 ? 0 : value > 0 ? 1 : -1);
        }
 
        template<typename T>
        T bell(T t, T strength)
        {
            return power<T>(4.0f, strength) * power<T>(t *(1.0f - t), strength);
        }
 
        template<typename T>
        T smoothStep(T value, T edge0, T edge1)
        {
            T x = math::clamp<T>((value - edge0) / (edge1 - edge0), 0, 1);
            return x * x * (3 - 2 * x);
        }
 
 
        // Forward declarations of template functions
 
        template<>
        NAPAPI float lerp<float>(const float& start, const float& end, float percent);
 
        template<>
        NAPAPI double lerp<double>(const double& start, const double& end, float percent);
 
        template<>
        NAPAPI glm::vec2 lerp<glm::vec2>(const glm::vec2& start, const glm::vec2& end, float percent);
 
        template<>
        NAPAPI glm::vec3 lerp<glm::vec3>(const glm::vec3& start, const glm::vec3& end, float percent);
 
        template<>
        NAPAPI glm::vec4 lerp<glm::vec4>(const glm::vec4& start, const glm::vec4& end, float percent);
 
        template<>
        NAPAPI float power<float>(float value, float exp);
 
        template<>
        NAPAPI double power<double>(double value, double exp);
 
        template<>
        NAPAPI int power<int>(int value, int exp);
 
        template<>
        NAPAPI void smooth(float& currentValue, const float& targetValue, float& currentVelocity, float deltaTime, float smoothTime, float maxSpeed);
 
        template<>
        NAPAPI void smooth(double& currentValue, const double& targetValue, double& currentVelocity, float deltaTime, float smoothTime, float maxSpeed);
 
        template<>
        NAPAPI void smooth(glm::vec2& currentValue, const glm::vec2& targetValue, glm::vec2& currentVelocity, float deltaTime, float smoothTime, float maxSpeed);
 
        template<>
        NAPAPI void smooth(glm::vec3& currentValue, const glm::vec3& targetValue, glm::vec3& currentVelocity, float deltaTime, float smoothTime, float maxSpeed);
 
        template<>
        NAPAPI void smooth(glm::vec4& currentValue, const glm::vec4& targetValue, glm::vec4& currentVelocity, float deltaTime, float smoothTime, float maxSpeed);
 
        template<>
        NAPAPI uint random(uint min, uint max);
 
        template<>
        NAPAPI int random(int min, int max);
 
        template<>
        NAPAPI float random(float min, float max);
 
        template<>
        NAPAPI glm::vec3 random(glm::vec3 min, glm::vec3 max);
 
        template<>
        NAPAPI glm::vec4 random(glm::vec4 min, glm::vec4 max);
 
        template<>
        NAPAPI glm::vec2 random(glm::vec2 min, glm::vec2 max);
 
        template<>
        NAPAPI glm::ivec2 random(glm::ivec2 min, glm::ivec2 max);
 
        template<>
        NAPAPI glm::ivec3 random(glm::ivec3 min, glm::ivec3 max);
 
        template<>
        NAPAPI glm::ivec4 random(glm::ivec4 min, glm::ivec4 max);
 
        template<>
        NAPAPI glm::mat4 random(glm::mat4 min, glm::mat4 max);
 
        template<>
        NAPAPI float abs(float value);
 
        template<>
        NAPAPI int abs(int value);
    }
}