math.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <cassert>
#include <tuple>
#include <type_traits>
#define GLM_ENABLE_EXPERIMENTAL
 
#include <glm/glm.hpp>
#include <glm/gtx/quaternion.hpp>
 
#include "NNL/common/constant.hpp"
#include "NNL/common/contract.hpp"
#include "NNL/common/fixed_type.hpp"
#include "NNL/utility/trait.hpp"
namespace nnl {
namespace utl::math {

inline bool IsNan(float value) { return std::isnan(value); }

template <typename TContainer>
bool IsNan(const TContainer& value) {
  static_assert(std::is_floating_point_v<typename TContainer::value_type>);
 
  return value != value;
}

inline bool IsFinite(float value) { return std::isfinite(value); }

template <typename TContainer>
bool IsFinite(const TContainer& container) {
  static_assert(std::is_floating_point_v<typename TContainer::value_type>);
 
  for (std::size_t i = 0; i < static_cast<std::size_t>(TContainer::length()); i++)
    if (!IsFinite(container[i])) return false;  // glm matrices, vectors
 
  return true;
}

glm::quat EulerToQuat(glm::vec3 euler);

glm::vec3 QuatToEuler(glm::quat quat);

std::tuple<glm::vec3, glm::quat, glm::vec3> Decompose(const glm::mat4& matrix);

glm::mat4 Compose(glm::vec3 scale, glm::quat rotation, glm::vec3 translation);

glm::mat4 InverseSafe(const glm::mat4& m);

glm::mat3 InverseSafe(const glm::mat3& m);

glm::mat4 Inverse(const glm::mat4& m);

glm::mat3 Inverse(const glm::mat3& m);
glm::vec3 NormalizeSafe(const glm::vec3& vec);
template <typename T>
constexpr inline T Sqr(T value) {
  static_assert(std::is_arithmetic_v<T>);
  return value * value;
}

template <typename T>
bool IsPow2(T n) {
  static_assert(std::is_integral_v<T>);
  return (n > 0 && ((n & (n - 1)) == 0));
}

inline u32 RoundUpPow2(u32 v) {
  NNL_EXPECTS_DBG(v >= 1 && v <= 2147483648);
  v--;
  v |= v >> 1;
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v++;
  return v;
}

inline u32 RoundDownPow2(u32 v) { return IsPow2(v) ? v : RoundUpPow2(v) >> 1; }

template <typename T>
T RoundNum(T number, std::size_t multiple) {
  static_assert(std::is_integral_v<T>);
 
  if (multiple == 0) return number;
 
  if (number % multiple != 0) return ((number / multiple) + 1) * multiple;
 
  return number;
}

template <typename T, std::size_t num_int = 0>
constexpr T FloatToFixed(f32 value) {
  static_assert(std::is_integral_v<T>);
  static_assert(num_int < std::numeric_limits<T>::digits, "no fractional bits");
  static_assert(sizeof(T) < sizeof(f32));
  NNL_EXPECTS_DBG(utl::math::IsFinite(value));
 
  std::size_t fraction = std::numeric_limits<T>::digits - num_int;
  f32 res = std::round(value * static_cast<f32>(1U << fraction));
  res = std::clamp<int>(res, std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
  return static_cast<T>(res);
}

template <typename T, std::size_t num_int = 0>
constexpr f32 FixedToFloat(T value) {
  static_assert(std::is_integral_v<T>);
  static_assert(num_int < std::numeric_limits<T>::digits, "no fractional bits");
  static_assert(sizeof(T) < sizeof(f32));
  std::size_t fraction = std::numeric_limits<T>::digits - num_int;
  f32 res = static_cast<f32>(value) / static_cast<f32>(1U << fraction);
  return res;
}

inline bool IsApproxEqual(float a, float b, float range = NNL_EPSILON) {
  if (std::abs(a - b) > range) return false;
  return true;
}

template <typename TContainer>
bool IsApproxEqual(TContainer a, TContainer b, float range = NNL_EPSILON) {
  static_assert(std::is_floating_point_v<typename TContainer::value_type>);
 
  std::size_t size = 0;
 
  if constexpr (utl::trait::has_size_member_v<TContainer>) {
    if (a.size() != b.size()) return false;
    size = static_cast<std::size_t>(a.size());
  } else {
    size = static_cast<std::size_t>(TContainer::length());
  }
 
  for (std::size_t i = 0; i < size; i++)
    if (!IsApproxEqual(a[i], b[i], range)) return false;
 
  return true;
}

}  // namespace utl::math
}  // namespace nnl