From cb2ee365b1066ee034cdf373c5b8ff90d7c58c39 Mon Sep 17 00:00:00 2001 From: BlackMATov Date: Fri, 4 Oct 2019 02:29:46 +0700 Subject: [PATCH] add rect and aabb bindings --- headers/enduro2d/math/aabb.hpp | 44 +++---- headers/enduro2d/math/rect.hpp | 44 +++---- sources/enduro2d/high/bindings/math_binds.cpp | 122 ++++++++++++++++++ untests/sources/untests_high/luasol.cpp | 13 ++ 4 files changed, 177 insertions(+), 46 deletions(-) diff --git a/headers/enduro2d/math/aabb.hpp b/headers/enduro2d/math/aabb.hpp index c2d94035..5f0d35c8 100644 --- a/headers/enduro2d/math/aabb.hpp +++ b/headers/enduro2d/math/aabb.hpp @@ -23,18 +23,18 @@ namespace e2d vec3 position; vec3 size; public: - static const aabb& zero() noexcept; - static const aabb& unit() noexcept; + static constexpr aabb zero() noexcept; + static constexpr aabb unit() noexcept; public: - aabb() noexcept = default; - aabb(const aabb& other) noexcept = default; - aabb& operator=(const aabb& other) noexcept = default; + constexpr aabb() noexcept = default; + constexpr aabb(const aabb& other) noexcept = default; + constexpr aabb& operator=(const aabb& other) noexcept = default; - aabb(T w, T h, T l) noexcept; - aabb(T x, T y, T z, T w, T h, T l) noexcept; + constexpr aabb(T w, T h, T l) noexcept; + constexpr aabb(T x, T y, T z, T w, T h, T l) noexcept; - aabb(const vec3& nsize) noexcept; - aabb(const vec3& nposition, const vec3& nsize) noexcept; + constexpr aabb(const vec3& nsize) noexcept; + constexpr aabb(const vec3& nposition, const vec3& nsize) noexcept; template < typename To > aabb cast_to() const noexcept; @@ -60,32 +60,30 @@ namespace e2d namespace e2d { template < typename T > - const aabb& aabb::zero() noexcept { - static const aabb zero{0, 0, 0, 0, 0, 0}; - return zero; + constexpr aabb aabb::zero() noexcept { + return {0, 0, 0, 0, 0, 0}; } template < typename T > - const aabb& aabb::unit() noexcept { - static const aabb unit{0, 0, 0, 1, 1, 1}; - return unit; + constexpr aabb aabb::unit() noexcept { + return {0, 0, 0, 1, 1, 1}; } template < typename T > - aabb::aabb(T w, T h, T l) noexcept + constexpr aabb::aabb(T w, T h, T l) noexcept : size(w, h, l) {} template < typename T > - aabb::aabb(T x, T y, T z, T w, T h, T l) noexcept + constexpr aabb::aabb(T x, T y, T z, T w, T h, T l) noexcept : position(x, y, z) , size(w, h, l) {} template < typename T > - aabb::aabb(const vec3& nsize) noexcept + constexpr aabb::aabb(const vec3& nsize) noexcept : size(nsize) {} template < typename T > - aabb::aabb(const vec3& nposition, const vec3& nsize) noexcept + constexpr aabb::aabb(const vec3& nposition, const vec3& nsize) noexcept : position(nposition) , size(nsize) {} @@ -175,22 +173,22 @@ namespace e2d // template < typename T > - aabb make_aabb(T w, T h, T l) noexcept { + constexpr aabb make_aabb(T w, T h, T l) noexcept { return {w, h, l}; } template < typename T > - aabb make_aabb(T x, T y, T z, T w, T h, T l) noexcept { + constexpr aabb make_aabb(T x, T y, T z, T w, T h, T l) noexcept { return {x, y, z, w, h, l}; } template < typename T > - aabb make_aabb(const vec3& size) noexcept { + constexpr aabb make_aabb(const vec3& size) noexcept { return {size}; } template < typename T > - aabb make_aabb(const vec3& position, const vec3& size) noexcept { + constexpr aabb make_aabb(const vec3& position, const vec3& size) noexcept { return {position, size}; } diff --git a/headers/enduro2d/math/rect.hpp b/headers/enduro2d/math/rect.hpp index 5aae3931..e974d9b3 100644 --- a/headers/enduro2d/math/rect.hpp +++ b/headers/enduro2d/math/rect.hpp @@ -23,18 +23,18 @@ namespace e2d vec2 position; vec2 size; public: - static const rect& zero() noexcept; - static const rect& unit() noexcept; + static constexpr rect zero() noexcept; + static constexpr rect unit() noexcept; public: - rect() noexcept = default; - rect(const rect& other) noexcept = default; - rect& operator=(const rect& other) noexcept = default; + constexpr rect() noexcept = default; + constexpr rect(const rect& other) noexcept = default; + constexpr rect& operator=(const rect& other) noexcept = default; - rect(T w, T h) noexcept; - rect(T x, T y, T w, T h) noexcept; + constexpr rect(T w, T h) noexcept; + constexpr rect(T x, T y, T w, T h) noexcept; - rect(const vec2& nsize) noexcept; - rect(const vec2& nposition, const vec2& nsize) noexcept; + constexpr rect(const vec2& nsize) noexcept; + constexpr rect(const vec2& nposition, const vec2& nsize) noexcept; template < typename To > rect cast_to() const noexcept; @@ -60,32 +60,30 @@ namespace e2d namespace e2d { template < typename T > - const rect& rect::zero() noexcept { - static const rect zero{0, 0, 0, 0}; - return zero; + constexpr rect rect::zero() noexcept { + return {0, 0, 0, 0}; } template < typename T > - const rect& rect::unit() noexcept { - static const rect unit{0, 0, 1, 1}; - return unit; + constexpr rect rect::unit() noexcept { + return {0, 0, 1, 1}; } template < typename T > - rect::rect(T w, T h) noexcept + constexpr rect::rect(T w, T h) noexcept : size(w, h) {} template < typename T > - rect::rect(T x, T y, T w, T h) noexcept + constexpr rect::rect(T x, T y, T w, T h) noexcept : position(x, y) , size(w, h) {} template < typename T > - rect::rect(const vec2& nsize) noexcept + constexpr rect::rect(const vec2& nsize) noexcept : size(nsize) {} template < typename T > - rect::rect(const vec2& nposition, const vec2& nsize) noexcept + constexpr rect::rect(const vec2& nposition, const vec2& nsize) noexcept : position(nposition) , size(nsize) {} @@ -175,22 +173,22 @@ namespace e2d // template < typename T > - rect make_rect(T w, T h) noexcept { + constexpr rect make_rect(T w, T h) noexcept { return {w, h}; } template < typename T > - rect make_rect(T x, T y, T w, T h) noexcept { + constexpr rect make_rect(T x, T y, T w, T h) noexcept { return {x, y, w, h}; } template < typename T > - rect make_rect(const vec2& size) noexcept { + constexpr rect make_rect(const vec2& size) noexcept { return {size}; } template < typename T > - rect make_rect(const vec2& position, const vec2& size) noexcept { + constexpr rect make_rect(const vec2& position, const vec2& size) noexcept { return {position, size}; } diff --git a/sources/enduro2d/high/bindings/math_binds.cpp b/sources/enduro2d/high/bindings/math_binds.cpp index 68af77b9..099b8d86 100644 --- a/sources/enduro2d/high/bindings/math_binds.cpp +++ b/sources/enduro2d/high/bindings/math_binds.cpp @@ -483,6 +483,126 @@ namespace "contains_nan", sol::resolve&)>(&math::contains_nan)); } + + template < typename T > + void bind_rect(const str& name, sol::state& l) { + l.new_usertype>(name, + sol::constructors< + rect(), + rect(rect), + rect(T,T), + rect(T,T,T,T), + rect(vec2), + rect(vec2,vec2)>(), + + "zero", &rect::zero, + "unit", &rect::unit, + + "position", &rect::position, + "size", &rect::size, + + sol::meta_function::equal_to, sol::resolve&, const rect&)>(::operator==), + sol::meta_function::less_than, sol::resolve&, const rect&)>(::operator<), + sol::meta_function::less_than_or_equal_to, sol::resolve&, const rect&)>(::operator<=), + + sol::meta_function::addition, sol::overload( + sol::resolve(const rect&, T)>(::operator+), + sol::resolve(const rect&, const vec2&)>(::operator+)), + + sol::meta_function::subtraction, sol::overload( + sol::resolve(const rect&, T)>(::operator-), + sol::resolve(const rect&, const vec2&)>(::operator-)), + + sol::meta_function::multiplication, sol::overload( + sol::resolve(const rect&, T)>(::operator*), + sol::resolve(const rect&, const vec2&)>(::operator*)), + + sol::meta_function::division, sol::overload( + sol::resolve(const rect&, T)>(::operator/), + sol::resolve(const rect&, const vec2&)>(::operator/)), + + "make_minmax_rect", sol::overload( + sol::resolve(T,T,T,T)>(&math::make_minmax_rect), + sol::resolve(const vec2&,const vec2&)>(&math::make_minmax_rect), + sol::resolve(const rect&)>(&math::make_minmax_rect)), + + "approximately", [](const rect& l, const rect& r){ return math::approximately(l,r); }, + + "minimum", sol::resolve(const rect&)>(&math::minimum), + "maximum", sol::resolve(const rect&)>(&math::maximum), + + "area", sol::resolve&)>(&math::area), + "abs_area", sol::resolve&)>(&math::abs_area), + + "merged", sol::resolve(const rect&,const rect&)>(&math::merged), + "inside", sol::resolve&,const vec2&)>(&math::inside), + "overlaps", sol::resolve&,const rect&)>(&math::overlaps), + + "normalized_to_point", sol::resolve(const rect&,const vec2&)>(&math::normalized_to_point), + "point_to_normalized", sol::resolve(const rect&,const vec2&)>(&math::point_to_normalized), + + "contains_nan", sol::resolve&)>(&math::contains_nan)); + } + + template < typename T > + void bind_aabb(const str& name, sol::state& l) { + l.new_usertype>(name, + sol::constructors< + aabb(), + aabb(aabb), + aabb(T,T,T), + aabb(T,T,T,T,T,T), + aabb(vec3), + aabb(vec3,vec3)>(), + + "zero", &aabb::zero, + "unit", &aabb::unit, + + "position", &aabb::position, + "size", &aabb::size, + + sol::meta_function::equal_to, sol::resolve&, const aabb&)>(::operator==), + sol::meta_function::less_than, sol::resolve&, const aabb&)>(::operator<), + sol::meta_function::less_than_or_equal_to, sol::resolve&, const aabb&)>(::operator<=), + + sol::meta_function::addition, sol::overload( + sol::resolve(const aabb&, T)>(::operator+), + sol::resolve(const aabb&, const vec3&)>(::operator+)), + + sol::meta_function::subtraction, sol::overload( + sol::resolve(const aabb&, T)>(::operator-), + sol::resolve(const aabb&, const vec3&)>(::operator-)), + + sol::meta_function::multiplication, sol::overload( + sol::resolve(const aabb&, T)>(::operator*), + sol::resolve(const aabb&, const vec3&)>(::operator*)), + + sol::meta_function::division, sol::overload( + sol::resolve(const aabb&, T)>(::operator/), + sol::resolve(const aabb&, const vec3&)>(::operator/)), + + "make_minmax_rect", sol::overload( + sol::resolve(T,T,T,T,T,T)>(&math::make_minmax_aabb), + sol::resolve(const vec3&,const vec3&)>(&math::make_minmax_aabb), + sol::resolve(const aabb&)>(&math::make_minmax_aabb)), + + "approximately", [](const aabb& l, const aabb& r){ return math::approximately(l,r); }, + + "minimum", sol::resolve(const aabb&)>(&math::minimum), + "maximum", sol::resolve(const aabb&)>(&math::maximum), + + "volume", sol::resolve&)>(&math::volume), + "abs_volume", sol::resolve&)>(&math::abs_volume), + + "merged", sol::resolve(const aabb&,const aabb&)>(&math::merged), + "inside", sol::resolve&,const vec3&)>(&math::inside), + "overlaps", sol::resolve&,const aabb&)>(&math::overlaps), + + "normalized_to_point", sol::resolve(const aabb&,const vec3&)>(&math::normalized_to_point), + "point_to_normalized", sol::resolve(const aabb&,const vec3&)>(&math::point_to_normalized), + + "contains_nan", sol::resolve&)>(&math::contains_nan)); + } } namespace e2d::bindings @@ -497,5 +617,7 @@ namespace e2d::bindings bind_mat2("m2f", l); bind_mat3("m3f", l); bind_mat4("m4f", l); + bind_rect("b2f", l); + bind_aabb("b3f", l); } } diff --git a/untests/sources/untests_high/luasol.cpp b/untests/sources/untests_high/luasol.cpp index cbd0f296..fa47ba5c 100644 --- a/untests/sources/untests_high/luasol.cpp +++ b/untests/sources/untests_high/luasol.cpp @@ -76,4 +76,17 @@ TEST_CASE("luasol") { REQUIRE(r2.second); REQUIRE(r2.first == math::inversed(math::make_translation_matrix4(2.f,3.f,4.f)).first); } + + SECTION("rect/aabb") { + bool r0 = l.lua().script(R"lua( + local b = b2f.unit() * 2 + return b:inside(v2f.new(1.5,1.5)) + )lua"); + REQUIRE(r0); + bool r1 = l.lua().script(R"lua( + local b = b3f.unit() * 2 + return b:overlaps(b3f.new(1.5,1.5,1.5,2,2,2)) + )lua"); + REQUIRE(r1); + } }