added more lua stuff

include/omath/linear_algebra/mat.hpp

@@ -123,7 +123,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        static consteval MatSize size() noexcept
+        static constexpr MatSize size() noexcept
         {
             return {Rows, Columns};
         }
@@ -854,4 +854,4 @@ struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> // NOLINT(*-dc
         if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
             return std::format_to(ctx.out(), u8"{}", mat.to_u8string());
     }
-};
+};

include/omath/lua/lua.hpp

@@ -15,11 +15,16 @@ namespace omath::lua
         static void register_vec2(sol::table& omath_table);
         static void register_vec3(sol::table& omath_table);
         static void register_vec4(sol::table& omath_table);
+        static void register_matrices(sol::table& omath_table);
+        static void register_quaternion(sol::table& omath_table);
         static void register_color(sol::table& omath_table);
+        static void register_hud(sol::table& omath_table);
         static void register_triangle(sol::table& omath_table);
+        static void register_3d_primitives(sol::table& omath_table);
+        static void register_collision(sol::table& omath_table);
         static void register_shared_types(sol::table& omath_table);
         static void register_engines(sol::table& omath_table);
         static void register_pattern_scan(sol::table& omath_table);
     };
 }
-#endif
+#endif

include/omath/projection/camera.hpp

@@ -107,7 +107,8 @@ namespace omath::projection
             // m[1,1] == 1 / tan(fov/2)  =>  fov = 2 * atan(1 / m[1,1])
             const auto f = proj_matrix.at(1, 1);
             // m[0,0] == m[1,1] / aspect_ratio  =>  aspect = m[1,1] / m[0,0]
-            return {FieldOfView::from_radians(NumericType{2} * std::atan(NumericType{1} / f)),
+            const auto fov_radians = NumericType{2} * std::atan(NumericType{1} / f);
+            return {FieldOfView::from_radians(static_cast<typename FieldOfView::ArithmeticType>(fov_radians)),
                     f / proj_matrix.at(0, 0)};
         }
 

source/lua/lua.cpp

@@ -17,8 +17,13 @@ namespace omath::lua
         register_vec2(omath_table);
         register_vec3(omath_table);
         register_vec4(omath_table);
+        register_matrices(omath_table);
+        register_quaternion(omath_table);
         register_color(omath_table);
+        register_hud(omath_table);
         register_triangle(omath_table);
+        register_3d_primitives(omath_table);
+        register_collision(omath_table);
         register_shared_types(omath_table);
         register_engines(omath_table);
         register_pattern_scan(omath_table);

source/lua/lua_collision.cpp

@@ -0,0 +1,304 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "omath/lua/lua.hpp"
+#include <omath/3d_primitives/aabb.hpp>
+#include <omath/3d_primitives/obb.hpp>
+#include <omath/collision/collider_interface.hpp>
+#include <omath/collision/epa_algorithm.hpp>
+#include <omath/collision/gjk_algorithm.hpp>
+#include <omath/collision/line_tracer.hpp>
+#include <omath/linear_algebra/triangle.hpp>
+#include <omath/linear_algebra/vector3.hpp>
+#include <sol/sol.hpp>
+#include <algorithm>
+#include <stdexcept>
+#include <vector>
+
+namespace
+{
+    using Vec3f = omath::Vector3<float>;
+    using Triangle3f = omath::Triangle<Vec3f>;
+    using Ray3f = omath::collision::Ray<Vec3f>;
+    using LineTracer3f = omath::collision::LineTracer<Ray3f>;
+    using Aabbf = omath::primitives::Aabb<float>;
+    using Obbf = omath::primitives::Obb<float>;
+
+    template<class Object, class Value>
+    auto lua_field(Value Object::* member)
+    {
+        return sol::property(
+                [member](const Object& object) -> const Value&
+                {
+                    return object.*member;
+                },
+                [member](Object& object, const Value& value)
+                {
+                    object.*member = value;
+                });
+    }
+
+    class LuaConvexCollider final : public omath::collision::ColliderInterface<Vec3f>
+    {
+    public:
+        using VectorType = Vec3f;
+
+        explicit LuaConvexCollider(std::vector<Vec3f> vertices, const Vec3f& origin = {})
+            : m_vertices(std::move(vertices)), m_origin(origin)
+        {
+            if (m_vertices.empty())
+                throw std::invalid_argument("convex collider must contain at least one vertex");
+        }
+
+        [[nodiscard]]
+        Vec3f find_abs_furthest_vertex_position(const Vec3f& direction) const override
+        {
+            const auto furthest = std::ranges::max_element(
+                    m_vertices,
+                    [&direction](const Vec3f& first, const Vec3f& second)
+                    {
+                        return first.dot(direction) < second.dot(direction);
+                    });
+
+            return m_origin + *furthest;
+        }
+
+        [[nodiscard]]
+        const Vec3f& get_origin() const override
+        {
+            return m_origin;
+        }
+
+        void set_origin(const Vec3f& new_origin) override
+        {
+            m_origin = new_origin;
+        }
+
+        [[nodiscard]]
+        std::size_t vertex_count() const noexcept
+        {
+            return m_vertices.size();
+        }
+
+        [[nodiscard]]
+        const std::vector<Vec3f>& vertices() const noexcept
+        {
+            return m_vertices;
+        }
+
+    private:
+        std::vector<Vec3f> m_vertices;
+        Vec3f m_origin;
+    };
+
+    std::vector<Vec3f> vec3_table_to_vector(const sol::table& points)
+    {
+        std::vector<Vec3f> result;
+        for (std::size_t i = 1;; ++i)
+        {
+            const auto point = points[i].get<sol::optional<Vec3f>>();
+            if (!point)
+                break;
+            result.push_back(*point);
+        }
+        return result;
+    }
+
+    sol::table vec3_array_to_table(const auto& points, sol::this_state state)
+    {
+        sol::state_view lua(state);
+        sol::table result = lua.create_table(static_cast<int>(points.size()), 0);
+        for (std::size_t i = 0; i < points.size(); ++i)
+            result[i + 1] = points[i];
+        return result;
+    }
+
+    Vec3f aabb_top(const Aabbf& aabb, const omath::primitives::UpAxis axis)
+    {
+        switch (axis)
+        {
+        case omath::primitives::UpAxis::X:
+            return aabb.top<omath::primitives::UpAxis::X>();
+        case omath::primitives::UpAxis::Y:
+            return aabb.top<omath::primitives::UpAxis::Y>();
+        case omath::primitives::UpAxis::Z:
+            return aabb.top<omath::primitives::UpAxis::Z>();
+        }
+        std::unreachable();
+    }
+
+    Vec3f aabb_bottom(const Aabbf& aabb, const omath::primitives::UpAxis axis)
+    {
+        switch (axis)
+        {
+        case omath::primitives::UpAxis::X:
+            return aabb.bottom<omath::primitives::UpAxis::X>();
+        case omath::primitives::UpAxis::Y:
+            return aabb.bottom<omath::primitives::UpAxis::Y>();
+        case omath::primitives::UpAxis::Z:
+            return aabb.bottom<omath::primitives::UpAxis::Z>();
+        }
+        std::unreachable();
+    }
+
+    bool ray_hits_triangle(const Ray3f& ray, const Triangle3f& triangle)
+    {
+        return !(LineTracer3f::get_ray_hit_point(ray, triangle) == ray.end);
+    }
+
+    bool ray_hits_aabb(const Ray3f& ray, const Aabbf& aabb)
+    {
+        return !(LineTracer3f::get_ray_hit_point(ray, aabb) == ray.end);
+    }
+
+    bool ray_hits_obb(const Ray3f& ray, const Obbf& obb)
+    {
+        return !(LineTracer3f::get_ray_hit_point(ray, obb) == ray.end);
+    }
+} // namespace
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_3d_primitives(sol::table& omath_table)
+    {
+        auto primitives_table = omath_table["primitives"].get_or_create<sol::table>();
+
+        primitives_table.new_enum("UpAxis", "X", omath::primitives::UpAxis::X, "Y", omath::primitives::UpAxis::Y, "Z",
+                                  omath::primitives::UpAxis::Z);
+
+        primitives_table.new_usertype<Aabbf>(
+                "Aabb",
+                sol::factories([]() { return Aabbf{}; },
+                               [](const Vec3f& min, const Vec3f& max) { return Aabbf{min, max}; }),
+
+                "min", lua_field(&Aabbf::min), "max", lua_field(&Aabbf::max), "center", &Aabbf::center, "extents",
+                &Aabbf::extents,
+                "top",
+                [](const Aabbf& aabb, sol::optional<omath::primitives::UpAxis> axis)
+                {
+                    return aabb_top(aabb, axis.value_or(omath::primitives::UpAxis::Y));
+                },
+                "bottom",
+                [](const Aabbf& aabb, sol::optional<omath::primitives::UpAxis> axis)
+                {
+                    return aabb_bottom(aabb, axis.value_or(omath::primitives::UpAxis::Y));
+                },
+                "is_collide", &Aabbf::is_collide,
+                "as_table",
+                [](const Aabbf& aabb, sol::this_state state) -> sol::table
+                {
+                    sol::state_view lua(state);
+                    sol::table result = lua.create_table();
+                    result["min"] = aabb.min;
+                    result["max"] = aabb.max;
+                    return result;
+                });
+
+        primitives_table.new_usertype<Obbf>(
+                "Obb",
+                sol::factories(
+                        []()
+                        {
+                            return Obbf{};
+                        },
+                        [](const Vec3f& center, const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z,
+                           const Vec3f& half_extents)
+                        {
+                            return Obbf{center, axis_x, axis_y, axis_z, half_extents};
+                        }),
+
+                "center", lua_field(&Obbf::center), "axis_x", lua_field(&Obbf::axis_x), "axis_y",
+                lua_field(&Obbf::axis_y), "axis_z", lua_field(&Obbf::axis_z), "half_extents",
+                lua_field(&Obbf::half_extents),
+                "vertices",
+                [](const Obbf& obb, sol::this_state state)
+                {
+                    return vec3_array_to_table(obb.vertices(), state);
+                });
+    }
+
+    void LuaInterpreter::register_collision(sol::table& omath_table)
+    {
+        auto collision_table = omath_table["collision"].get_or_create<sol::table>();
+
+        collision_table.new_usertype<Ray3f>(
+                "Ray",
+                sol::factories([]() { return Ray3f{}; },
+                               [](const Vec3f& start, const Vec3f& end) { return Ray3f{start, end}; },
+                               [](const Vec3f& start, const Vec3f& end, const bool infinite_length)
+                               { return Ray3f{start, end, infinite_length}; }),
+
+                "start", lua_field(&Ray3f::start), "end", lua_field(&Ray3f::end), "infinite_length",
+                lua_field(&Ray3f::infinite_length),
+                "direction_vector", &Ray3f::direction_vector, "direction_vector_normalized",
+                &Ray3f::direction_vector_normalized);
+
+        collision_table.new_usertype<LuaConvexCollider>(
+                "ConvexCollider",
+                sol::factories([](const sol::table& vertices) { return LuaConvexCollider(vec3_table_to_vector(vertices)); },
+                               [](const sol::table& vertices, const Vec3f& origin)
+                               { return LuaConvexCollider(vec3_table_to_vector(vertices), origin); }),
+
+                "find_abs_furthest_vertex_position", &LuaConvexCollider::find_abs_furthest_vertex_position,
+                "get_origin", &LuaConvexCollider::get_origin, "set_origin", &LuaConvexCollider::set_origin,
+                "vertex_count", &LuaConvexCollider::vertex_count,
+                "vertices",
+                [](const LuaConvexCollider& collider, sol::this_state state)
+                {
+                    return vec3_array_to_table(collider.vertices(), state);
+                });
+
+        collision_table.new_usertype<LineTracer3f>(
+                "LineTracer", sol::no_constructor, "can_trace_line", &LineTracer3f::can_trace_line,
+                "get_ray_hit_point",
+                sol::overload(
+                        [](const Ray3f& ray, const Triangle3f& triangle)
+                        {
+                            return LineTracer3f::get_ray_hit_point(ray, triangle);
+                        },
+                        [](const Ray3f& ray, const Aabbf& aabb)
+                        {
+                            return LineTracer3f::get_ray_hit_point(ray, aabb);
+                        },
+                        [](const Ray3f& ray, const Obbf& obb)
+                        {
+                            return LineTracer3f::get_ray_hit_point(ray, obb);
+                        }),
+                "ray_hits_triangle", &ray_hits_triangle, "ray_hits_aabb", &ray_hits_aabb, "ray_hits_obb",
+                &ray_hits_obb);
+
+        collision_table["gjk_support_vertex"] =
+                [](const LuaConvexCollider& collider_a, const LuaConvexCollider& collider_b, const Vec3f& direction)
+        { return omath::collision::GjkAlgorithm<LuaConvexCollider>::find_support_vertex(collider_a, collider_b, direction); };
+
+        collision_table["gjk_collide"] = [](const LuaConvexCollider& collider_a, const LuaConvexCollider& collider_b)
+        { return omath::collision::GjkAlgorithm<LuaConvexCollider>::is_collide(collider_a, collider_b); };
+
+        collision_table["epa_solve"] = [](const LuaConvexCollider& collider_a, const LuaConvexCollider& collider_b,
+                                          sol::this_state state) -> sol::object
+        {
+            using Gjk = omath::collision::GjkAlgorithm<LuaConvexCollider>;
+            using Epa = omath::collision::Epa<LuaConvexCollider>;
+
+            sol::state_view lua(state);
+            const auto gjk = Gjk::is_collide_with_simplex_info(collider_a, collider_b);
+            if (!gjk.hit)
+                return sol::nil;
+
+            const auto epa = Epa::solve(collider_a, collider_b, gjk.simplex);
+            if (!epa)
+                return sol::nil;
+
+            sol::table result = lua.create_table();
+            result["normal"] = epa->normal;
+            result["penetration_vector"] = epa->penetration_vector;
+            result["depth"] = epa->depth;
+            result["iterations"] = epa->iterations;
+            result["num_vertices"] = epa->num_vertices;
+            result["num_faces"] = epa->num_faces;
+            return sol::make_object(lua, result);
+        };
+    }
+} // namespace omath::lua
+#endif