Math.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_MATH_H
#define GF_MATH_H

#include <cmath>
#include <limits>

#include "Portability.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  template<typename T>
  constexpr
  T pi() {
    return T(3.141592653589793238462643383279502884197169399L);
  }

  constexpr float Pi = pi<float>();

  constexpr float Pi2 = Pi / 2;

  constexpr float Pi3 = Pi / 3;

  constexpr float Pi4 = Pi / 4;

  constexpr float Pi6 = Pi / 6;

  constexpr float Sqrt2 = 1.41421356237309504880f;

  constexpr float InvSqrt2 = 1 / Sqrt2;

  constexpr float Sqrt3 = 1.7320508075688772935f;

  constexpr float Epsilon = std::numeric_limits<float>::epsilon();

  template<typename T>
  constexpr
  bool almostEquals(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) {
    if (a == b) {
      return true;
    }

    T diff = std::abs(a - b);

    if (a == 0 || b == 0 || diff < std::numeric_limits<T>::denorm_min()) {
      return diff < (epsilon * std::numeric_limits<T>::denorm_min());
    }

    T sum = std::abs(a) + std::abs(b);
    sum = (sum < std::numeric_limits<T>::max()) ? sum : std::numeric_limits<T>::max();

    return (diff / sum) < epsilon;
  }

  template<typename T>
  constexpr
  T degreesToRadians(T degrees) {
    return degrees * gf::pi<T>() / T(180);
  }

  template<typename T>
  constexpr
  T radiansToDegrees(T radians) {
    return radians * T(180) / gf::pi<T>();
  }

  template<typename T>
  using Step = T (*)(T);

  template<typename T>
  constexpr
  T linearStep(T t) {
    return t;
  }

  template<typename T>
  constexpr
  T cubicStep(T t) {
    return (-T(2) * t + T(3)) * t * t;
  }

  template<typename T>
  constexpr
  T quinticStep(T t) {
    return ((T(6) * t - T(15)) * t + T(10)) * t * t * t;
  }

  template<typename T>
  inline
  T cosineStep(T t) {
    return (T(1) - std::cos(gf::pi<T>() * t)) * T(0.5);
  }

  template<typename T, typename U>
  constexpr
  T lerp(T lhs, T rhs, U t) {
    return (U(1) - t) * lhs + t * rhs;
  }

  template<typename T>
  constexpr
  T clamp(T val, T lo, T hi) {
    return val < lo ? lo : (val > hi ? hi : val);
  }

  template<typename T>
  constexpr
  T square(T val) {
    return val * val;
  }

  template<typename T>
  constexpr
  T cube(T val) {
    return val * val * val;
  }

  template<typename T>
  constexpr
  int sign(T val) {
    return (val > T(0)) - (val < T(0));
  }

  template<typename T>
  constexpr
  T absdiff(T lhs, T rhs) {
    return lhs > rhs ? lhs - rhs : rhs - lhs;
  }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_MATH_H