Graft header-only math::AABB<T> from qfengine

3 files changed, 112 insertions, 74 deletions

diff --git a/core/math/CMakeLists.txt b/core/math/CMakeLists.txt
index 692492e..b994969 100644
--- a/core/math/CMakeLists.txt
+++ b/core/math/CMakeLists.txt
@@ -1,5 +1,4 @@
 target_sources(core PRIVATE
-    "${CMAKE_CURRENT_LIST_DIR}/aabb.cc"
     "${CMAKE_CURRENT_LIST_DIR}/aabb.hh"
     "${CMAKE_CURRENT_LIST_DIR}/angles.hh"
     "${CMAKE_CURRENT_LIST_DIR}/concepts.hh"
diff --git a/core/math/aabb.cc b/core/math/aabb.cc
deleted file mode 100644
index 1111149..0000000
--- a/core/math/aabb.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "core/pch.hh"

-

-#include "core/math/aabb.hh"

-

-math::AABB::AABB(const glm::fvec3& min, const glm::fvec3& max)

-{

-    set_bounds(min, max);

-}

-

-void math::AABB::set_bounds(const glm::fvec3& min, const glm::fvec3& max)

-{

-    this->min = min;

-    this->max = max;

-}

-

-void math::AABB::set_offset(const glm::fvec3& base, const glm::fvec3& size)

-{

-    this->min = base;

-    this->max = base + size;

-}

-

-bool math::AABB::contains(const glm::fvec3& point) const

-{

-    auto result = true;

-    result = result && (point.x >= min.x) && (point.x <= max.x);

-    result = result && (point.y >= min.y) && (point.y <= max.y);

-    result = result && (point.z >= min.z) && (point.z <= max.z);

-    return result;

-}

-

-bool math::AABB::intersect(const AABB& other_box) const

-{

-    auto result = true;

-    result = result && (min.x < other_box.max.x) && (max.x > other_box.min.x);

-    result = result && (min.y < other_box.max.y) && (max.y > other_box.min.y);

-    result = result && (min.z < other_box.max.z) && (max.z > other_box.min.z);

-    return result;

-}

-

-math::AABB math::AABB::combine_with(const math::AABB& other_box) const

-{

-    AABB result;

-    result.set_bounds(min, other_box.max);

-    return result;

-}

-

-math::AABB math::AABB::multiply_with(const math::AABB& other_box) const

-{

-    AABB result;

-    result.set_bounds(other_box.min, max);

-    return result;

-}

-

-math::AABB math::AABB::push(const glm::fvec3& vector) const

-{

-    AABB result;

-    result.set_bounds(min + vector, max + vector);

-    return result;

-}

diff --git a/core/math/aabb.hh b/core/math/aabb.hh
index bff8e04..59a345a 100644
--- a/core/math/aabb.hh
+++ b/core/math/aabb.hh
@@ -1,28 +1,126 @@
 #pragma once

 

+#include "core/math/concepts.hh"

+

 namespace math

 {

-class AABB final {

+template<Arithmetic T>

+class AABB {

 public:

-    AABB(void) = default;

-    explicit AABB(const glm::fvec3& min, const glm::fvec3& max);

+    using value_type = T;

+    using vector_type = glm::vec<3, T>;

+

+    constexpr AABB(void) = default;

+    constexpr explicit AABB(const vector_type& start, const vector_type& end);

     virtual ~AABB(void) = default;

 

-    void set_bounds(const glm::fvec3& min, const glm::fvec3& max);

-    void set_offset(const glm::fvec3& base, const glm::fvec3& size);

+    constexpr void set_bounds(const vector_type& start, const vector_type& end);

+    constexpr void set_offset(const vector_type& base, const vector_type& size);

 

-    const glm::fvec3& get_min(void) const;

-    const glm::fvec3& get_max(void) const;

+    constexpr const vector_type& get_min(void) const;

+    constexpr const vector_type& get_max(void) const;

 

-    bool contains(const glm::fvec3& point) const;

-    bool intersect(const AABB& other_box) const;

+    constexpr bool contains(const vector_type& point) const;

+    constexpr bool intersect(const AABB<value_type>& other_box) const;

 

-    AABB combine_with(const AABB& other_box) const;

-    AABB multiply_with(const AABB& other_box) const;

-    AABB push(const glm::fvec3& vector) const;

+    constexpr AABB<value_type> combine(const AABB<value_type>& other_box) const;

+    constexpr AABB<value_type> multiply(const AABB<value_type>& other_box) const;

+    constexpr AABB<value_type> push(const vector_type& vector) const;

 

 public:

-    glm::fvec3 min;

-    glm::fvec3 max;

+    vector_type min {};

+    vector_type max {};

 };

 } // namespace math

+

+namespace math

+{

+using AABBf = AABB<float>;

+} // namespace math

+

+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>

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

+{

+    min = start;

+    max = end;

+}

+

+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>

+constexpr const typename math::AABB<T>::vector_type& math::AABB<T>::get_min(void) const

+{

+    return min;

+}

+

+template<math::Arithmetic T>

+constexpr const typename math::AABB<T>::vector_type& math::AABB<T>::get_max(void) const

+{

+    return max;

+}

+

+template<math::Arithmetic T>

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

+{

+    auto result = true;

+    result = result && (point.x >= min.x) && (point.x <= max.x);

+    result = result && (point.y >= min.y) && (point.y <= max.y);

+    result = result && (point.z >= min.z) && (point.z <= max.z);

+    return result;

+}

+

+template<math::Arithmetic T>

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

+{

+    auto result = true;

+    result = result && (min.x <= other_box.max.x) && (max.x >= other_box.min.x);

+    result = result && (min.y <= other_box.max.y) && (max.y >= other_box.min.y);

+    result = result && (min.z <= other_box.max.z) && (max.z >= other_box.min.z);

+    return result;

+}

+

+template<math::Arithmetic T>

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

+{

+    AABB<value_type> result;

+    result.min.x = glm::min(min.x, other_box.min.x);

+    result.min.y = glm::min(min.y, other_box.min.y);

+    result.min.z = glm::min(min.z, other_box.min.z);

+    result.max.x = glm::max(max.x, other_box.max.x);

+    result.max.y = glm::max(max.y, other_box.max.y);

+    result.max.z = glm::max(max.z, other_box.max.z);

+    return result;

+}

+

+template<math::Arithmetic T>

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

+{

+    AABB<value_type> result;

+    result.min.x = glm::max(min.x, other_box.min.x);

+    result.min.y = glm::max(min.y, other_box.min.y);

+    result.min.z = glm::max(min.z, other_box.min.z);

+    result.max.x = glm::min(max.x, other_box.max.x);

+    result.max.y = glm::min(max.y, other_box.max.y);

+    result.max.z = glm::min(max.z, other_box.max.z);

+    return result;

+}

+

+template<math::Arithmetic T>

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

+{

+    AABB<value_type> result;

+    result.min = min + vector;

+    result.max = max + vector;

+    return result;

+}