admin/omath
1
0
Fork 0
mirror of https://github.com/orange-cpp/omath.git synced 2026-02-13 07:03:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: Simplify GJK simplex handling

Browse Source 
Removes the separate `Simplex` class and integrates its functionality directly into the `GjkAlgorithm`. This simplifies the code and reduces unnecessary overhead.

Updates tests to align with refactored implementation.
This commit is contained in:
Orange
2025-11-09 16:02:13 +03:00
parent 015fc9b1e7
commit afc0720f08
4 changed files with 110 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/omath/collision/gjk_algorithm.hpp
View File

@@ -9,12 +9,14 @@
namespace omath::collision namespace omath::collision
{ {
template<class ColliderType = MeshCollider>
class GjkAlgorithm final class GjkAlgorithm final
{ {
public: public:
[[nodiscard]] [[nodiscard]]
static Vector3<float> find_support_vertex(const MeshCollider& collider_a, const MeshCollider& collider_b, static MeshCollider::VertexType find_support_vertex(const ColliderType& collider_a,
const Vector3<float>& direction) const ColliderType& collider_b,
const MeshCollider::VertexType& direction)
{ {
return collider_a.find_abs_furthest_vertex(direction) - collider_b.find_abs_furthest_vertex(-direction); return collider_a.find_abs_furthest_vertex(direction) - collider_b.find_abs_furthest_vertex(-direction);
} }
@@ -25,7 +27,7 @@ namespace omath::collision
// Get initial support point in any direction // Get initial support point in any direction
auto support = find_support_vertex(collider_a, collider_b, {1, 0, 0}); auto support = find_support_vertex(collider_a, collider_b, {1, 0, 0});
Simplex simplex; Simplex<MeshCollider::VertexType> simplex;
simplex.push_front(support); simplex.push_front(support);
auto direction = -support; auto direction = -support;
@@ -44,4 +46,4 @@ namespace omath::collision
} }
} }
}; };
}// namespace omath::collision } // namespace omath::collision

1
include/omath/collision/mesh_collider.hpp
View File

@@ -12,6 +12,7 @@ namespace omath::collision
class MeshCollider class MeshCollider
{ {
public: public:
using VertexType = Vector3<float>;
MeshCollider(const std::vector<Vector3<float>>& vertexes, const Vector3<float> origin) MeshCollider(const std::vector<Vector3<float>>& vertexes, const Vector3<float> origin)
: m_vertexes(vertexes), m_origin(origin) : m_vertexes(vertexes), m_origin(origin)
{ {

141
include/omath/collision/simplex.hpp
View File

@@ -1,65 +1,114 @@
//
// Created by Vlad on 11/9/2025.
//
#pragma once #pragma once
#include "omath/linear_algebra/vector3.hpp" #include "omath/linear_algebra/vector3.hpp"
#include <array> #include <array>
#include <cassert>
#include <initializer_list>
#include <type_traits>
namespace omath::collision namespace omath::collision
{ {
template<class VectorType = Vector3<float>>
// Minimal structural contract for the vector type used by GJK.
template<class V>
concept GjkVector = requires(const V& a, const V& b) {
{ -a } -> std::same_as<V>;
{ a - b } -> std::same_as<V>;
{ a.cross(b) } -> std::same_as<V>;
{ a.point_to_same_direction(b) } -> std::same_as<bool>;
};
template<GjkVector VectorType = Vector3<float>>
class Simplex final class Simplex final
{ {
std::array<VectorType, 4> m_points; std::array<VectorType, 4> m_points{}; // value-initialized
std::size_t m_size; std::size_t m_size{0};
public: public:
constexpr Simplex(): m_size(0) static constexpr std::size_t capacity = 4;
{
}
constexpr Simplex& operator=(const std::initializer_list<VectorType>& list) constexpr Simplex() = default;
// Keep your convenient "{a, b, c}" assignments, but guard size.
constexpr Simplex& operator=(std::initializer_list<VectorType> list) noexcept
{ {
assert(list.size() <= capacity && "Simplex can have at most 4 points");
m_size = 0; m_size = 0;
for (const auto& p : list)
for (const VectorType& point : list) m_points[m_size++] = p;
m_points[m_size++] = point;
return *this; return *this;
} }
constexpr void push_front(const VectorType& point) // Safe push_front: only shifts the valid range; no reads from uninitialized slots.
constexpr void push_front(const VectorType& p) noexcept
{ {
m_points = {point, m_points[0], m_points[1], m_points[2]}; const std::size_t limit = (m_size < capacity) ? m_size : capacity - 1;
m_size = std::min<std::size_t>(m_size + 1, 4); for (std::size_t i = limit; i > 0; --i)
m_points[i] = m_points[i - 1];
m_points[0] = p;
if (m_size < capacity)
++m_size;
} }
constexpr const VectorType& operator[](const std::size_t i) const // Accessors
constexpr const VectorType& operator[](std::size_t i) const noexcept
{ {
return m_points[i]; return m_points[i];
} }
[[nodiscard]] constexpr VectorType& operator[](std::size_t i) noexcept
constexpr std::size_t size() const {
return m_points[i];
}
[[nodiscard]] constexpr std::size_t size() const noexcept
{ {
return m_size; return m_size;
} }
[[nodiscard]] [[nodiscard]] constexpr bool empty() const noexcept
constexpr auto begin() const {
return m_size == 0;
}
[[nodiscard]] constexpr const VectorType& front() const noexcept
{
return m_points[0];
}
[[nodiscard]] constexpr const VectorType& back() const noexcept
{
return m_points[m_size - 1];
}
[[nodiscard]] constexpr const VectorType* data() const noexcept
{
return m_points.data();
}
[[nodiscard]] constexpr auto begin() const noexcept
{ {
return m_points.begin(); return m_points.begin();
} }
[[nodiscard]]
constexpr auto end() const [[nodiscard]] constexpr auto end() const noexcept
{ {
return m_points.end() - (4 - m_size); return m_points.begin() + m_size;
} }
[[nodiscard]]
constexpr bool handle(VectorType& direction) constexpr void clear() noexcept
{ {
switch (size()) m_size = 0;
}
// GJK step: updates simplex + next search direction.
// Returns true iff the origin lies inside the tetrahedron.
[[nodiscard]] constexpr bool handle(VectorType& direction) noexcept
{ {
switch (m_size)
{
case 0:
return false;
case 1:
return handle_point(direction);
case 2: case 2:
return handle_line(direction); return handle_line(direction);
case 3: case 3:
@@ -70,29 +119,36 @@ namespace omath::collision
std::unreachable(); std::unreachable();
} }
} }
private: private:
[[nodiscard]] [[nodiscard]] constexpr bool handle_point(VectorType& direction) noexcept
constexpr bool handle_line(VectorType& direction) {
const auto& a = m_points[0];
direction = -a;
return false;
}
[[nodiscard]] constexpr bool handle_line(VectorType& direction) noexcept
{ {
const auto& a = m_points[0]; const auto& a = m_points[0];
const auto& b = m_points[1]; const auto& b = m_points[1];
const auto ab = b - a; const auto ab = b - a;
// ReSharper disable once CppTooWideScopeInitStatement
const auto ao = -a; const auto ao = -a;
if (ab.point_to_same_direction(ao)) if (ab.point_to_same_direction(ao))
{
direction = ab.cross(ao).cross(ab); direction = ab.cross(ao).cross(ab);
}
else else
{ {
*this = {a}; *this = {a};
direction = ao; direction = ao;
} }
return false; return false;
} }
[[nodiscard]]
constexpr bool handle_triangle(VectorType& direction) [[nodiscard]] constexpr bool handle_triangle(VectorType& direction) noexcept
{ {
const auto& a = m_points[0]; const auto& a = m_points[0];
const auto& b = m_points[1]; const auto& b = m_points[1];
@@ -104,38 +160,40 @@ namespace omath::collision
const auto abc = ab.cross(ac); const auto abc = ab.cross(ac);
// Region AC
if (abc.cross(ac).point_to_same_direction(ao)) if (abc.cross(ac).point_to_same_direction(ao))
{ {
if (ac.point_to_same_direction(ao)) if (ac.point_to_same_direction(ao))
{ {
*this = {a, c}; *this = {a, c};
direction = ac.cross(ao).cross(ac); direction = ac.cross(ao).cross(ac);
return false; return false;
} }
*this = {a, b}; *this = {a, b};
return handle_line(direction); return handle_line(direction);
} }
// Region AB
if (ab.cross(abc).point_to_same_direction(ao)) if (ab.cross(abc).point_to_same_direction(ao))
{ {
*this = {a, b}; *this = {a, b};
return handle_line(direction); return handle_line(direction);
} }
// Above or below triangle
if (abc.point_to_same_direction(ao)) if (abc.point_to_same_direction(ao))
{ {
direction = abc; direction = abc;
} }
else else
{ {
*this = {a, c, b}; *this = {a, c, b}; // flip winding
direction = -abc; direction = -abc;
} }
return false; return false;
} }
[[nodiscard]]
constexpr bool handle_tetrahedron(VectorType& direction) [[nodiscard]] constexpr bool handle_tetrahedron(VectorType& direction) noexcept
{ {
const auto& a = m_points[0]; const auto& a = m_points[0];
const auto& b = m_points[1]; const auto& b = m_points[1];
@@ -156,18 +214,17 @@ namespace omath::collision
*this = {a, b, c}; *this = {a, b, c};
return handle_triangle(direction); return handle_triangle(direction);
} }
if (acd.point_to_same_direction(ao)) if (acd.point_to_same_direction(ao))
{ {
*this = {a, c, d}; *this = {a, c, d};
return handle_triangle(direction); return handle_triangle(direction);
} }
if (adb.point_to_same_direction(ao)) if (adb.point_to_same_direction(ao))
{ {
*this = {a, d, b}; *this = {a, d, b};
return handle_triangle(direction); return handle_triangle(direction);
} }
// Origin inside tetrahedron
return true; return true;
} }
}; };

6
tests/general/unit_test_gjk.cpp
View File

@@ -20,7 +20,7 @@ TEST(UnitTestGjk, TestCollisionTrue)
const omath::collision::MeshCollider collider_a(mesh, {0.f, 0.f, 0.f}); const omath::collision::MeshCollider collider_a(mesh, {0.f, 0.f, 0.f});
const omath::collision::MeshCollider collider_b(mesh, {0.f, 0.5f, 0.f}); const omath::collision::MeshCollider collider_b(mesh, {0.f, 0.5f, 0.f});
const auto result = omath::collision::GjkAlgorithm::is_collide(collider_a, collider_b); const auto result = omath::collision::GjkAlgorithm<>::is_collide(collider_a, collider_b);
EXPECT_TRUE(result); EXPECT_TRUE(result);
} }
@@ -38,9 +38,9 @@ TEST(UnitTestGjk, TestCollisionFalse)
}; };
const omath::collision::MeshCollider collider_a(mesh, {0.f, 0.f, 0.f}); const omath::collision::MeshCollider collider_a(mesh, {0.f, 0.f, 0.f});
const omath::collision::MeshCollider collider_b(mesh, {0.f, 4.1f, 0.f}); const omath::collision::MeshCollider collider_b(mesh, {0.f, 2.1f, 0.f});
const auto result = omath::collision::GjkAlgorithm::is_collide(collider_a, collider_b); const auto result = omath::collision::GjkAlgorithm<>::is_collide(collider_a, collider_b);
EXPECT_FALSE(result); EXPECT_FALSE(result);
} }