Skip to content

Featue/aabb improvement #183

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
orange-cpp merged 2 commits into from
Apr 19, 2026
Merged

Featue/aabb improvement #183

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
dfd18e9
added aabb improvemnt
orange-cpp Apr 19, 2026
1c0619f
added new methods
orange-cpp Apr 19, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
39 changes: 39 additions & 0 deletions include/omath/3d_primitives/aabb.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,8 @@

namespace omath::primitives
{
enum class UpAxis { X, Y, Z };

template<class Type>
struct Aabb final
{
Expand All @@ -24,5 +26,42 @@ namespace omath::primitives
{
return (max - min) / static_cast<Type>(2);
}

template<UpAxis Up = UpAxis::Y>
[[nodiscard]]
constexpr Vector3<Type> top() const noexcept
{
const auto aabb_center = center();
if constexpr (Up == UpAxis::Z)
return {aabb_center.x, aabb_center.y, max.z};
else if constexpr (Up == UpAxis::X)
return {max.x, aabb_center.y, aabb_center.z};
else if constexpr (Up == UpAxis::Y)
return {aabb_center.x, max.y, aabb_center.z};
else
std::unreachable();
}

template<UpAxis Up = UpAxis::Y>
[[nodiscard]]
constexpr Vector3<Type> bottom() const noexcept
{
const auto aabb_center = center();
if constexpr (Up == UpAxis::Z)
return {aabb_center.x, aabb_center.y, min.z};
else if constexpr (Up == UpAxis::X)
return {min.x, aabb_center.y, aabb_center.z};
else if constexpr (Up == UpAxis::Y)
return {aabb_center.x, min.y, aabb_center.z};
else
std::unreachable();
}

[[nodiscard]]
constexpr bool is_collide(const Aabb& other) const noexcept
{
return min.x <= other.max.x && max.x >= other.min.x &&
min.y <= other.max.y && max.y >= other.min.y &&min.z <= other.max.z && max.z >= other.min.z;
}
};
} // namespace omath::primitives
84 changes: 47 additions & 37 deletions tests/general/mem_fd_helper.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,19 +20,19 @@
#include <vector>

#if defined(__linux__)
# include <unistd.h>
# include <fcntl.h>
# if defined(__ANDROID__)
# if __ANDROID_API__ >= 30
# include <sys/mman.h>
# define OMATH_TEST_USE_MEMFD 1
# endif
#include <fcntl.h>
#include <unistd.h>
#if defined(__ANDROID__)
#if __ANDROID_API__ >= 30
#include <sys/mman.h>
#define OMATH_TEST_USE_MEMFD 1
#endif
// Android < 30: fall through to tmpfile() path below
# else
#else
// Desktop Linux: memfd_create available since glibc 2.27 / kernel 3.17
# include <sys/mman.h>
# define OMATH_TEST_USE_MEMFD 1
# endif
#include <sys/mman.h>
#define OMATH_TEST_USE_MEMFD 1
#endif
#endif

class MemFdFile
Expand All @@ -57,9 +57,11 @@ class MemFdFile
MemFdFile(MemFdFile&& o) noexcept
: m_path(std::move(o.m_path))
#if defined(OMATH_TEST_USE_MEMFD)
, m_fd(o.m_fd)
,
m_fd(o.m_fd)
#else
, m_temp_path(std::move(o.m_temp_path))
,
m_temp_path(std::move(o.m_temp_path))
#endif
{
#if defined(OMATH_TEST_USE_MEMFD)
Expand All @@ -69,9 +71,15 @@ class MemFdFile
#endif
}

[[nodiscard]] bool valid() const { return !m_path.empty(); }
[[nodiscard]] bool valid() const
{
return !m_path.empty();
}

[[nodiscard]] const std::filesystem::path& path() const { return m_path; }
[[nodiscard]] const std::filesystem::path& path() const
{
return m_path;
}

static MemFdFile create(const std::vector<std::uint8_t>& data)
{
Expand Down Expand Up @@ -101,7 +109,7 @@ class MemFdFile
std::mt19937_64 rng(std::random_device{}());
const auto unique_name = "omath_test_" + std::to_string(rng()) + ".bin";
f.m_temp_path = (tmp_dir / unique_name).string();
f.m_path = f.m_temp_path;
f.m_path = f.m_temp_path;

std::ofstream out(f.m_temp_path, std::ios::binary | std::ios::trunc);
if (!out.is_open())
Expand Down Expand Up @@ -153,38 +161,40 @@ class MemFdFile
// ---------------------------------------------------------------------------
inline std::vector<std::uint8_t> build_minimal_pe(const std::vector<std::uint8_t>& section_bytes)
{
constexpr std::uint32_t e_lfanew = 0x80u;
constexpr std::uint16_t size_opt = 0xF0u;
constexpr std::size_t nt_off = e_lfanew;
constexpr std::size_t fh_off = nt_off + 4;
constexpr std::size_t oh_off = fh_off + 20;
constexpr std::size_t sh_off = oh_off + size_opt;
constexpr std::size_t data_off = sh_off + 44;
constexpr std::uint32_t e_lfanew = 0x80u;
constexpr std::uint16_t size_opt = 0xF0u;
constexpr std::size_t nt_off = e_lfanew;
constexpr std::size_t fh_off = nt_off + 4;
constexpr std::size_t oh_off = fh_off + 20;
constexpr std::size_t sh_off = oh_off + size_opt;
constexpr std::size_t data_off = sh_off + 44;

std::vector<std::uint8_t> buf(data_off + section_bytes.size(), 0u);

buf[0] = 'M'; buf[1] = 'Z';
buf[0] = 'M';
buf[1] = 'Z';
std::memcpy(buf.data() + 0x3Cu, &e_lfanew, 4);

buf[nt_off] = 'P'; buf[nt_off + 1] = 'E';
buf[nt_off] = 'P';
buf[nt_off + 1] = 'E';

const std::uint16_t machine = 0x8664u, num_sections = 1u;
std::memcpy(buf.data() + fh_off, &machine, 2);
std::memcpy(buf.data() + fh_off + 2, &num_sections, 2);
std::memcpy(buf.data() + fh_off + 16, &size_opt, 2);
constexpr std::uint16_t machine = 0x8664u, num_sections = 1u;
std::memcpy(buf.data() + fh_off, &machine, 2);
std::memcpy(buf.data() + fh_off + 2, &num_sections, 2);
std::memcpy(buf.data() + fh_off + 16, &size_opt, 2);

const std::uint16_t magic = 0x20Bu;
constexpr std::uint16_t magic = 0x20Bu;
std::memcpy(buf.data() + oh_off, &magic, 2);

const char name[8] = {'.','t','e','x','t',0,0,0};
constexpr char name[8] = {'.', 't', 'e', 'x', 't', 0, 0, 0};
std::memcpy(buf.data() + sh_off, name, 8);

const auto vsize = static_cast<std::uint32_t>(section_bytes.size());
const std::uint32_t vaddr = 0x1000u;
const auto ptr_raw = static_cast<std::uint32_t>(data_off);
std::memcpy(buf.data() + sh_off + 8, &vsize, 4);
std::memcpy(buf.data() + sh_off + 12, &vaddr, 4);
std::memcpy(buf.data() + sh_off + 16, &vsize, 4);
const auto vsize = static_cast<std::uint32_t>(section_bytes.size());
constexpr std::uint32_t vaddr = 0x1000u;
constexpr auto ptr_raw = static_cast<std::uint32_t>(data_off);
std::memcpy(buf.data() + sh_off + 8, &vsize, 4);
std::memcpy(buf.data() + sh_off + 12, &vaddr, 4);
std::memcpy(buf.data() + sh_off + 16, &vsize, 4);
std::memcpy(buf.data() + sh_off + 20, &ptr_raw, 4);

std::memcpy(buf.data() + data_off, section_bytes.data(), section_bytes.size());
Expand Down
Loading
Loading