Cleanup math with qfengine ports again

8 files changed, 71 insertions, 248 deletions

diff --git a/core/math/CMakeLists.txt b/core/math/CMakeLists.txt
index b994969..bcb45aa 100644
--- a/core/math/CMakeLists.txt
+++ b/core/math/CMakeLists.txt
@@ -5,5 +5,4 @@ target_sources(core PRIVATE
     "${CMAKE_CURRENT_LIST_DIR}/constexpr.hh"
     "${CMAKE_CURRENT_LIST_DIR}/crc64.cc"
     "${CMAKE_CURRENT_LIST_DIR}/crc64.hh"
-    "${CMAKE_CURRENT_LIST_DIR}/randomizer.hh"
     "${CMAKE_CURRENT_LIST_DIR}/vectors.hh")
diff --git a/core/math/aabb.hh b/core/math/aabb.hh
index ed3cf39..9a64aad 100644
--- a/core/math/aabb.hh
+++ b/core/math/aabb.hh
@@ -4,7 +4,7 @@
 

 namespace math

 {

-template<Arithmetic T>

+template<arithmetic T>

 class AABB {

 public:

     using value_type = T;

@@ -35,27 +35,27 @@ namespace math
 using AABBf = AABB<float>;

 } // namespace math

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr math::AABB<T>::AABB(const vector_type& start, const vector_type& end)

 {

     set_bounds(start, end);

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr void math::AABB<T>::set_bounds(const vector_type& start, const vector_type& end)

 {

     min = start;

     max = end;

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr void math::AABB<T>::set_offset(const vector_type& base, const vector_type& size)

 {

     min = base;

     max = base + size;

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr bool math::AABB<T>::contains(const vector_type& point) const

 {

     auto result = true;

@@ -65,7 +65,7 @@ constexpr bool math::AABB<T>::contains(const vector_type& point) const
     return result;

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr bool math::AABB<T>::intersect(const AABB<value_type>& other_box) const

 {

     auto result = true;

@@ -75,7 +75,7 @@ constexpr bool math::AABB<T>::intersect(const AABB<value_type>& other_box) const
     return result;

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr math::AABB<T> math::AABB<T>::combine(const AABB<value_type>& other_box) const

 {

     AABB<value_type> result;

@@ -88,7 +88,7 @@ constexpr math::AABB<T> math::AABB<T>::combine(const AABB<value_type>& other_box
     return result;

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr math::AABB<T> math::AABB<T>::multiply(const AABB<value_type>& other_box) const

 {

     AABB<value_type> result;

@@ -101,7 +101,7 @@ constexpr math::AABB<T> math::AABB<T>::multiply(const AABB<value_type>& other_bo
     return result;

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr math::AABB<T> math::AABB<T>::push(const vector_type& vector) const

 {

     AABB<value_type> result;

diff --git a/core/math/concepts.hh b/core/math/concepts.hh
index 10cb74a..19d372c 100644
--- a/core/math/concepts.hh
+++ b/core/math/concepts.hh
@@ -2,10 +2,10 @@
 

 namespace math

 {

-template<typename T>

-concept Arithmetic = std::is_arithmetic_v<T>;

-template<typename T>

-concept Integer = std::is_integral_v<T>;

-template<typename T>

-concept FloatingPoint = std::is_floating_point_v<T>;

+template<typename type>

+concept arithmetic = std::is_arithmetic_v<type>;

+template<typename type>

+concept signed_arithmetic = std::is_arithmetic_v<type> && std::is_signed_v<type>;

+template<typename type>

+concept unsigned_arithmetic = std::is_arithmetic_v<type> && std::is_unsigned_v<type>;

 } // namespace math

diff --git a/core/math/constexpr.hh b/core/math/constexpr.hh
index e6c4b6d..6641f23 100644
--- a/core/math/constexpr.hh
+++ b/core/math/constexpr.hh
@@ -4,195 +4,69 @@
 

 namespace math

 {

-template<math::Arithmetic T>

-constexpr static inline const T abs(const T x);

-template<typename T, std::size_t L>

-constexpr static inline const std::size_t array_size(const T (&)[L]);

-template<math::Integer T, math::FloatingPoint F>

-constexpr static inline const T ceil(const F x);

-template<math::Arithmetic T>

-constexpr static inline const T degrees(const T x);

-template<math::Integer T, math::FloatingPoint F>

-constexpr static inline const T floor(const F x);

-template<math::Arithmetic T>

-constexpr static inline const T clamp(const T x, const T min, const T max);

-template<math::Arithmetic T, math::FloatingPoint F>

-constexpr static inline const T lerp(const T x, const T y, const F a);

-template<math::Arithmetic T>

-constexpr static inline const T log2(const T x);

-template<math::Arithmetic T>

-constexpr static inline const T max(const T x, const T y);

-template<math::Arithmetic T>

-constexpr static inline const T min(const T x, const T y);

-template<math::Integer T>

-requires std::is_signed_v<T>

-constexpr static inline const T mod_signed(const T x, const T m);

-template<math::Arithmetic T>

-constexpr static inline const T pow2(const T x);

-template<math::Arithmetic T>

-constexpr static inline const T radians(const T x);

-template<math::Arithmetic T>

-constexpr static inline const bool range(const T x, const T min, const T max);

-template<math::Arithmetic T, math::FloatingPoint F>

-constexpr static inline const T sign(const F x);

-template<math::Arithmetic T, math::FloatingPoint F>

-constexpr static inline const T smoothstep(const T x, const T y, const F a);

+template<typename type, std::size_t size>

+constexpr std::size_t array_size(const type (&)[size]);

 } // namespace math

 

-template<math::Arithmetic T>

-constexpr static inline const T math::abs(const T x)

-{

-    if(x < static_cast<T>(0)) {

-        return -x;

-    }

-    else {

-        return x;

-    }

-}

-

-template<typename T, std::size_t L>

-constexpr static inline const std::size_t math::array_size(const T (&)[L])

-{

-    return L;

-}

-

-template<math::Integer T, math::FloatingPoint F>

-constexpr static inline const T math::ceil(const F x)

-{

-    const T ival = static_cast<T>(x);

-

-    if(ival < x) {

-        return ival + static_cast<T>(1);

-    }

-    else {

-        return ival;

-    }

-}

-

-template<math::Arithmetic T>

-constexpr static inline const T math::degrees(const T x)

-{

-    return x * static_cast<T>(180.0) / static_cast<T>(M_PI);

-}

-

-template<math::Integer T, math::FloatingPoint F>

-constexpr static inline const T math::floor(const F x)

-{

-    const T ival = static_cast<T>(x);

-

-    if(ival > x) {

-        return ival - static_cast<T>(1);

-    }

-    else {

-        return ival;

-    }

-}

-

-template<math::Arithmetic T>

-constexpr static inline const T math::clamp(const T x, const T min, const T max)

-{

-    if(x < min) {

-        return min;

-    }

-    else if(x > max) {

-        return max;

-    }

-    else {

-        return x;

-    }

-}

-

-template<math::Arithmetic T, math::FloatingPoint F>

-constexpr static inline const T math::lerp(const T x, const T y, const F a)

+namespace math

 {

-    return static_cast<T>(static_cast<F>(x) * (static_cast<F>(1.0f) - a) + static_cast<F>(y) * a);

-}

+template<std::integral scalar>

+constexpr scalar log2(const scalar x);

+template<std::signed_integral scalar>

+constexpr scalar mod_signed(const scalar x, const scalar m);

+template<math::signed_arithmetic result_scalar, math::arithmetic scalar>

+constexpr result_scalar sign(const scalar x);

+} // namespace math

 

-template<math::Arithmetic T>

-constexpr static inline const T math::log2(const T x)

+namespace math

 {

-    if(x < 2) {

-        return 0;

-    }

-    else {

-        return math::log2<T>((x + 1) >> 1) + 1;

-    }

-}

+template<math::arithmetic scalar>

+constexpr scalar degrees(const scalar x);

+template<math::arithmetic scalar>

+constexpr scalar radians(const scalar x);

+} // namespace math

 

-template<math::Arithmetic T>

-constexpr static inline const T math::max(const T x, const T y)

+template<typename type, std::size_t size>

+constexpr std::size_t math::array_size(const type (&)[size])

 {

-    if(x < y) {

-        return y;

-    }

-    else {

-        return x;

-    }

+    return size;

 }

 

-template<math::Arithmetic T>

-constexpr static inline const T math::min(const T x, const T y)

+template<std::integral scalar>

+constexpr scalar math::log2(const scalar x)

 {

-    if(x > y) {

-        return y;

-    }

-    else {

-        return x;

-    }

+    if(x < static_cast<scalar>(2))

+        return static_cast<scalar>(0);

+    return math::log2<scalar>((x + static_cast<scalar>(1)) >> 1) + static_cast<scalar>(1);

 }

 

-template<math::Integer T>

-requires std::is_signed_v<T>

-constexpr static inline const T math::mod_signed(const T x, const T m)

+template<std::signed_integral scalar>

+constexpr scalar math::mod_signed(const scalar x, const scalar m)

 {

-    auto result = static_cast<T>(x % m);

-

-    if(result < T(0)) {

+    auto result = static_cast<scalar>(x % m);

+    if(result < static_cast<scalar>(0))

         return result + m;

-    }

-    else {

-        return result;

-    }

-}

-

-template<math::Arithmetic T>

-constexpr static inline const T math::pow2(const T x)

-{

-    T value = static_cast<T>(1);

-    while(value < x)

-        value *= static_cast<T>(2);

-    return value;

-}

-

-template<math::Arithmetic T>

-constexpr static inline const T math::radians(const T x)

-{

-    return x * static_cast<T>(M_PI) / static_cast<T>(180.0);

+    return result;

 }

 

-template<math::Arithmetic T>

-constexpr static inline const bool math::range(const T x, const T min, const T max)

+template<math::signed_arithmetic result_scalar, math::arithmetic scalar>

+constexpr result_scalar math::sign(const scalar x)

 {

-    return ((x >= min) && (x <= max));

+    if(x < static_cast<scalar>(0))

+        return static_cast<result_scalar>(-1);

+    if(x > static_cast<scalar>(0))

+        return static_cast<result_scalar>(+1);

+    return static_cast<result_scalar>(0);

 }

 

-template<math::Arithmetic T, math::FloatingPoint F>

-constexpr static inline const T math::sign(const F x)

+template<math::arithmetic scalar>

+constexpr scalar math::degrees(const scalar x)

 {

-    if(x < F(0)) {

-        return T(-1);

-    }

-    else if(x > F(0)) {

-        return T(+1);

-    }

-    else {

-        return T(0);

-    }

+    return static_cast<scalar>(static_cast<double>(x) * 180.0 / M_PI);

 }

 

-template<math::Arithmetic T, math::FloatingPoint F>

-constexpr static inline const T math::smoothstep(const T x, const T y, const F a)

+template<math::arithmetic scalar>

+constexpr scalar math::radians(const scalar x)

 {

-    const F t = math::clamp<F>((a - x) / (y - x), F(0), F(1));

-    return static_cast<T>(t * t * (F(3) - F(2) * t));

+    return static_cast<scalar>(static_cast<double>(x) * M_PI / 180.0);

 }

diff --git a/core/math/crc64.cc b/core/math/crc64.cc
index 0b6a830..ea7841d 100644
--- a/core/math/crc64.cc
+++ b/core/math/crc64.cc
@@ -69,3 +69,8 @@ std::uint64_t math::crc64(const std::string& buffer, std::uint64_t combine)
 {

     return math::crc64(buffer.data(), buffer.size(), combine);

 }

+

+std::uint64_t math::crc64(std::string_view buffer, std::uint64_t combine)

+{

+    return math::crc64(buffer.data(), buffer.size(), combine);

+}

diff --git a/core/math/crc64.hh b/core/math/crc64.hh
index f68c951..5a6fea4 100644
--- a/core/math/crc64.hh
+++ b/core/math/crc64.hh
@@ -5,4 +5,5 @@ namespace math
 std::uint64_t crc64(const void* buffer, std::size_t size, std::uint64_t combine = UINT64_C(0));

 std::uint64_t crc64(const std::vector<std::byte>& buffer, std::uint64_t combine = UINT64_C(0));

 std::uint64_t crc64(const std::string& buffer, std::uint64_t combine = UINT64_C(0));

+std::uint64_t crc64(std::string_view buffer, std::uint64_t combine = UINT64_C(0));

 } // namespace math

diff --git a/core/math/randomizer.hh b/core/math/randomizer.hh
deleted file mode 100644
index db21c95..0000000
--- a/core/math/randomizer.hh
+++ /dev/null
@@ -1,56 +0,0 @@
-#pragma once

-

-namespace math

-{

-template<typename T>

-class Randomizer final {

-public:

-    explicit Randomizer(void);

-    explicit Randomizer(std::uint64_t seed);

-    virtual ~Randomizer(void) = default;

-    void add(const T& value);

-    const T& get(void);

-    void clear(void);

-

-private:

-    std::vector<T> m_vector;

-    std::mt19937_64 m_twister;

-    std::uniform_int_distribution<std::size_t> m_dist;

-};

-} // namespace math

-

-template<typename T>

-inline math::Randomizer<T>::Randomizer(void)

-{

-    m_vector.clear();

-    m_twister.seed(std::random_device()());

-    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);

-}

-

-template<typename T>

-inline math::Randomizer<T>::Randomizer(std::uint64_t seed)

-{

-    m_vector.clear();

-    m_twister.seed(seed);

-    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);

-}

-

-template<typename T>

-inline void math::Randomizer<T>::add(const T& value)

-{

-    m_vector.push_back(value);

-    m_dist = std::uniform_int_distribution<std::size_t>(0, m_vector.size() - 1);

-}

-

-template<typename T>

-inline const T& math::Randomizer<T>::get(void)

-{

-    return m_vector.at(m_dist(m_twister));

-}

-

-template<typename T>

-inline void math::Randomizer<T>::clear(void)

-{

-    m_vector.clear();

-    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);

-}

diff --git a/core/math/vectors.hh b/core/math/vectors.hh
index 9b9e762..ff2b8c9 100644
--- a/core/math/vectors.hh
+++ b/core/math/vectors.hh
@@ -8,35 +8,35 @@
 

 namespace math

 {

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T length2(const glm::vec<2, T>& vector);

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T length2(const glm::vec<3, T>& vector);

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b);

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b);

 } // namespace math

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T math::length2(const glm::vec<2, T>& vector)

 {

     return (vector.x * vector.x) + (vector.y * vector.y);

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T math::length2(const glm::vec<3, T>& vector)

 {

     return (vector.x * vector.x) + (vector.y * vector.y) + (vector.z * vector.z);

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T math::distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b)

 {

     return math::length2(vector_a - vector_b);

 }

 

-template<math::Arithmetic T>

+template<math::arithmetic T>

 constexpr static inline const T math::distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b)

 {

     return math::length2(vector_a - vector_b);