Math.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2017 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

  constexpr float Pi = 3.14159265358979323846f;

  constexpr float Pi2 = Pi / 2;

  constexpr float Pi4 = Pi / 4;

  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>
  inline
  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;
  }

  constexpr float degreesToRadians(float degrees) {
    return degrees * Pi / 180.0f;
  }

  constexpr float radiansToDegrees(float radians) {
    return radians * 180.0f / Pi;
  }

  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 (-2 * t + 3) * t * t;
  }

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

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

  template<typename T, typename U>
  inline
  T lerp(T lhs, T rhs, U t) {
    return (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
  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