add quat and unit bindings

headers/enduro2d/math/_math.hpp

@@ -136,6 +136,9 @@ namespace e2d
     using deg = unit<T, deg_tag>;
     template < typename T >
     using rad = unit<T, rad_tag>;
+
+    using degf = deg<f32>;
+    using radf = rad<f32>;
 }
 
 namespace e2d::math

headers/enduro2d/math/quat.hpp

@@ -28,15 +28,15 @@ namespace e2d
         T z = 0;
         T w = 1;
     public:
-        static const quat& zero() noexcept;
+        static constexpr quat zero() noexcept;
-        static const quat& identity() noexcept;
+        static constexpr quat identity() noexcept;
     public:
-        quat() noexcept = default;
+        constexpr quat() noexcept = default;
-        quat(const quat& other) noexcept = default;
+        constexpr quat(const quat& other) noexcept = default;
-        quat& operator=(const quat& other) noexcept = default;
+        constexpr quat& operator=(const quat& other) noexcept = default;
 
-        quat(T x, T y, T z, T w) noexcept;
+        constexpr quat(T x, T y, T z, T w) noexcept;
-        explicit quat(const vec4<T>& other) noexcept;
+        constexpr explicit quat(const vec4<T>& other) noexcept;
 
         template < typename To >
         quat<To> cast_to() const noexcept;
@@ -58,26 +58,24 @@ namespace e2d
 namespace e2d
 {
     template < typename T >
-    const quat<T>& quat<T>::zero() noexcept {
+    constexpr quat<T> quat<T>::zero() noexcept {
-        static const quat<T> zero{0, 0, 0, 0};
+        return {0, 0, 0, 0};
-        return zero;
     }
 
     template < typename T >
-    const quat<T>& quat<T>::identity() noexcept {
+    constexpr quat<T> quat<T>::identity() noexcept {
-        static const quat<T> identity{0, 0, 0, 1};
+        return {0, 0, 0, 1};
-        return identity;
     }
 
     template < typename T >
-    quat<T>::quat(T nx, T ny, T nz, T nw) noexcept
+    constexpr quat<T>::quat(T nx, T ny, T nz, T nw) noexcept
     : x(nx)
     , y(ny)
     , z(nz)
     , w(nw) {}
 
     template < typename T >
-    quat<T>::quat(const vec4<T>& other) noexcept
+    constexpr quat<T>::quat(const vec4<T>& other) noexcept
     : x(other.x)
     , y(other.y)
     , z(other.z)
@@ -143,12 +141,12 @@ namespace e2d
     //
 
     template < typename T >
-    quat<T> make_quat(T x, T y, T z, T w) noexcept {
+    constexpr quat<T> make_quat(T x, T y, T z, T w) noexcept {
         return quat<T>(x, y, z, w);
     }
 
     template < typename T >
-    quat<T> make_quat(const vec4<T>& other) noexcept {
+    constexpr quat<T> make_quat(const vec4<T>& other) noexcept {
         return quat<T>(other);
     }
 

headers/enduro2d/math/unit.hpp

@@ -22,12 +22,13 @@ namespace e2d
     public:
         T value = 0;
     public:
-        unit() noexcept = default;
+        constexpr unit() noexcept = default;
-        unit(const unit& other) noexcept = default;
+        constexpr unit(const unit& other) noexcept = default;
-        unit& operator=(const unit& other) noexcept = default;
+        constexpr unit& operator=(const unit& other) noexcept = default;
+
+        constexpr explicit unit(T v) noexcept;
+        constexpr unit(T v, Tag tag) noexcept;
 
-        explicit unit(T v) noexcept;
-        unit(T v, Tag tag) noexcept;
         template < typename OtherTag >
         explicit unit(const unit<T, OtherTag>& other) noexcept;
 
@@ -59,11 +60,11 @@ namespace e2d
 namespace e2d
 {
     template < typename T, typename Tag >
-    unit<T, Tag>::unit(T v) noexcept
+    constexpr unit<T, Tag>::unit(T v) noexcept
     : value(v) {}
 
     template < typename T, typename Tag >
-    unit<T, Tag>::unit(T v, Tag tag) noexcept
+    constexpr unit<T, Tag>::unit(T v, Tag tag) noexcept
     : value(v) { E2D_UNUSED(tag); }
 
     template < typename T, typename Tag >
@@ -116,7 +117,7 @@ namespace e2d
     //
 
     template < typename Tag, typename T >
-    unit<T, Tag> make_unit(T v) noexcept {
+    constexpr unit<T, Tag> make_unit(T v) noexcept {
         return unit<T, Tag>(v);
     }
 

headers/enduro2d/math/vec2.hpp

@@ -24,19 +24,19 @@ namespace e2d
         T x = 0;
         T y = 0;
     public:
-        static const vec2& zero() noexcept;
+        static constexpr vec2 zero() noexcept;
-        static const vec2& unit() noexcept;
+        static constexpr vec2 unit() noexcept;
-        static const vec2& unit_x() noexcept;
+        static constexpr vec2 unit_x() noexcept;
-        static const vec2& unit_y() noexcept;
+        static constexpr vec2 unit_y() noexcept;
     public:
-        vec2() noexcept = default;
+        constexpr vec2() noexcept = default;
-        vec2(const vec2& other) noexcept = default;
+        constexpr vec2(const vec2& other) noexcept = default;
-        vec2& operator=(const vec2& other) noexcept = default;
+        constexpr vec2& operator=(const vec2& other) noexcept = default;
 
-        explicit vec2(T v) noexcept;
+        constexpr explicit vec2(T v) noexcept;
-        vec2(T x, T y) noexcept;
+        constexpr vec2(T x, T y) noexcept;
-        explicit vec2(const vec3<T>& other) noexcept;
+        constexpr explicit vec2(const vec3<T>& other) noexcept;
-        explicit vec2(const vec4<T>& other) noexcept;
+        constexpr explicit vec2(const vec4<T>& other) noexcept;
 
         template < typename To >
         vec2<To> cast_to() const noexcept;
@@ -62,46 +62,42 @@ namespace e2d
 namespace e2d
 {
     template < typename T >
-    const vec2<T>& vec2<T>::zero() noexcept {
+    constexpr vec2<T> vec2<T>::zero() noexcept {
-        static const vec2<T> zero{0, 0};
+        return {0, 0};
-        return zero;
     }
 
     template < typename T >
-    const vec2<T>& vec2<T>::unit() noexcept {
+    constexpr vec2<T> vec2<T>::unit() noexcept {
-        static const vec2<T> unit{1, 1};
+        return {1, 1};
-        return unit;
     }
 
     template < typename T >
-    const vec2<T>& vec2<T>::unit_x() noexcept {
+    constexpr vec2<T> vec2<T>::unit_x() noexcept {
-        static const vec2<T> unit_x{1, 0};
+        return {1, 0};
-        return unit_x;
     }
 
     template < typename T >
-    const vec2<T>& vec2<T>::unit_y() noexcept {
+    constexpr vec2<T> vec2<T>::unit_y() noexcept {
-        static const vec2<T> unit_y{0, 1};
+        return {0, 1};
-        return unit_y;
     }
 
     template < typename T >
-    vec2<T>::vec2(T v) noexcept
+    constexpr vec2<T>::vec2(T v) noexcept
     : x(v)
     , y(v) {}
 
     template < typename T >
-    vec2<T>::vec2(T nx, T ny) noexcept
+    constexpr vec2<T>::vec2(T nx, T ny) noexcept
     : x(nx)
     , y(ny) {}
 
     template < typename T >
-    vec2<T>::vec2(const vec3<T>& other) noexcept
+    constexpr vec2<T>::vec2(const vec3<T>& other) noexcept
     : x(other.x)
     , y(other.y) {}
 
     template < typename T >
-    vec2<T>::vec2(const vec4<T>& other) noexcept
+    constexpr vec2<T>::vec2(const vec4<T>& other) noexcept
     : x(other.x)
     , y(other.y) {}
 
@@ -202,22 +198,22 @@ namespace e2d
     //
 
     template < typename T >
-    vec2<T> make_vec2(T v) noexcept {
+    constexpr vec2<T> make_vec2(T v) noexcept {
         return vec2<T>(v);
     }
 
     template < typename T >
-    vec2<T> make_vec2(T x, T y) noexcept {
+    constexpr vec2<T> make_vec2(T x, T y) noexcept {
         return vec2<T>(x, y);
     }
 
     template < typename T >
-    vec2<T> make_vec2(const vec3<T>& other) noexcept {
+    constexpr vec2<T> make_vec2(const vec3<T>& other) noexcept {
         return vec2<T>(other);
     }
 
     template < typename T >
-    vec2<T> make_vec2(const vec4<T>& other) noexcept {
+    constexpr vec2<T> make_vec2(const vec4<T>& other) noexcept {
         return vec2<T>(other);
     }
 

headers/enduro2d/math/vec3.hpp

@@ -25,20 +25,20 @@ namespace e2d
         T y = 0;
         T z = 0;
     public:
-        static const vec3& zero() noexcept;
+        static constexpr vec3 zero() noexcept;
-        static const vec3& unit() noexcept;
+        static constexpr vec3 unit() noexcept;
-        static const vec3& unit_x() noexcept;
+        static constexpr vec3 unit_x() noexcept;
-        static const vec3& unit_y() noexcept;
+        static constexpr vec3 unit_y() noexcept;
-        static const vec3& unit_z() noexcept;
+        static constexpr vec3 unit_z() noexcept;
     public:
-        vec3() noexcept = default;
+        constexpr vec3() noexcept = default;
-        vec3(const vec3& other) noexcept = default;
+        constexpr vec3(const vec3& other) noexcept = default;
-        vec3& operator=(const vec3& other) noexcept = default;
+        constexpr vec3& operator=(const vec3& other) noexcept = default;
 
-        explicit vec3(T v) noexcept;
+        constexpr explicit vec3(T v) noexcept;
-        vec3(T x, T y, T z) noexcept;
+        constexpr vec3(T x, T y, T z) noexcept;
-        explicit vec3(const vec2<T>& other, T z) noexcept;
+        constexpr explicit vec3(const vec2<T>& other, T z) noexcept;
-        explicit vec3(const vec4<T>& other) noexcept;
+        constexpr explicit vec3(const vec4<T>& other) noexcept;
 
         template < typename To >
         vec3<To> cast_to() const noexcept;
@@ -64,55 +64,50 @@ namespace e2d
 namespace e2d
 {
     template < typename T >
-    const vec3<T>& vec3<T>::zero() noexcept {
+    constexpr vec3<T> vec3<T>::zero() noexcept {
-        static const vec3<T> zero{0, 0, 0};
+        return {0, 0, 0};
-        return zero;
     }
 
     template < typename T >
-    const vec3<T>& vec3<T>::unit() noexcept {
+    constexpr vec3<T> vec3<T>::unit() noexcept {
-        static const vec3<T> unit{1, 1, 1};
+        return {1, 1, 1};
-        return unit;
     }
 
     template < typename T >
-    const vec3<T>& vec3<T>::unit_x() noexcept {
+    constexpr vec3<T> vec3<T>::unit_x() noexcept {
-        static const vec3<T> unit_x{1, 0, 0};
+        return {1, 0, 0};
-        return unit_x;
     }
 
     template < typename T >
-    const vec3<T>& vec3<T>::unit_y() noexcept {
+    constexpr vec3<T> vec3<T>::unit_y() noexcept {
-        static const vec3<T> unit_y{0, 1, 0};
+        return {0, 1, 0};
-        return unit_y;
     }
 
     template < typename T >
-    const vec3<T>& vec3<T>::unit_z() noexcept {
+    constexpr vec3<T> vec3<T>::unit_z() noexcept {
-        static const vec3<T> unit_z{0, 0, 1};
+        return {0, 0, 1};
-        return unit_z;
     }
 
     template < typename T >
-    vec3<T>::vec3(T v) noexcept
+    constexpr vec3<T>::vec3(T v) noexcept
     : x(v)
     , y(v)
     , z(v) {}
 
     template < typename T >
-    vec3<T>::vec3(T nx, T ny, T nz) noexcept
+    constexpr vec3<T>::vec3(T nx, T ny, T nz) noexcept
     : x(nx)
     , y(ny)
     , z(nz) {}
 
     template < typename T >
-    vec3<T>::vec3(const vec2<T>& other, T nz) noexcept
+    constexpr vec3<T>::vec3(const vec2<T>& other, T nz) noexcept
     : x(other.x)
     , y(other.y)
     , z(nz) {}
 
     template < typename T >
-    vec3<T>::vec3(const vec4<T>& other) noexcept
+    constexpr vec3<T>::vec3(const vec4<T>& other) noexcept
     : x(other.x)
     , y(other.y)
     , z(other.z) {}
@@ -224,22 +219,22 @@ namespace e2d
     //
 
     template < typename T >
-    vec3<T> make_vec3(T v) noexcept {
+    constexpr vec3<T> make_vec3(T v) noexcept {
         return vec3<T>(v);
     }
 
     template < typename T >
-    vec3<T> make_vec3(T x, T y, T z) noexcept {
+    constexpr vec3<T> make_vec3(T x, T y, T z) noexcept {
         return vec3<T>(x, y, z);
     }
 
     template < typename T >
-    vec3<T> make_vec3(const vec2<T>& other, T z) noexcept {
+    constexpr vec3<T> make_vec3(const vec2<T>& other, T z) noexcept {
         return vec3<T>(other, z);
     }
 
     template < typename T >
-    vec3<T> make_vec3(const vec4<T>& other) noexcept {
+    constexpr vec3<T> make_vec3(const vec4<T>& other) noexcept {
         return vec3<T>(other);
     }
 

headers/enduro2d/math/vec4.hpp

@@ -26,21 +26,21 @@ namespace e2d
         T z = 0;
         T w = 0;
     public:
-        static const vec4& zero() noexcept;
+        static constexpr vec4 zero() noexcept;
-        static const vec4& unit() noexcept;
+        static constexpr vec4 unit() noexcept;
-        static const vec4& unit_x() noexcept;
+        static constexpr vec4 unit_x() noexcept;
-        static const vec4& unit_y() noexcept;
+        static constexpr vec4 unit_y() noexcept;
-        static const vec4& unit_z() noexcept;
+        static constexpr vec4 unit_z() noexcept;
-        static const vec4& unit_w() noexcept;
+        static constexpr vec4 unit_w() noexcept;
     public:
-        vec4() noexcept = default;
+        constexpr vec4() noexcept = default;
-        vec4(const vec4& other) noexcept = default;
+        constexpr vec4(const vec4& other) noexcept = default;
-        vec4& operator=(const vec4& other) noexcept = default;
+        constexpr vec4& operator=(const vec4& other) noexcept = default;
 
-        explicit vec4(T v) noexcept;
+        constexpr explicit vec4(T v) noexcept;
-        vec4(T x, T y, T z, T w) noexcept;
+        constexpr vec4(T x, T y, T z, T w) noexcept;
-        explicit vec4(const vec2<T>& other, T z, T w) noexcept;
+        constexpr explicit vec4(const vec2<T>& other, T z, T w) noexcept;
-        explicit vec4(const vec3<T>& other, T w) noexcept;
+        constexpr explicit vec4(const vec3<T>& other, T w) noexcept;
 
         template < typename To >
         vec4<To> cast_to() const noexcept;
@@ -66,64 +66,58 @@ namespace e2d
 namespace e2d
 {
     template < typename T >
-    const vec4<T>& vec4<T>::zero() noexcept {
+    constexpr vec4<T> vec4<T>::zero() noexcept {
-        static const vec4<T> zero{0, 0, 0, 0};
+        return {0, 0, 0, 0};
-        return zero;
     }
 
     template < typename T >
-    const vec4<T>& vec4<T>::unit() noexcept {
+    constexpr vec4<T> vec4<T>::unit() noexcept {
-        static const vec4<T> unit{1, 1, 1, 1};
+        return {1, 1, 1, 1};
-        return unit;
     }
 
     template < typename T >
-    const vec4<T>& vec4<T>::unit_x() noexcept {
+    constexpr vec4<T> vec4<T>::unit_x() noexcept {
-        static const vec4<T> unit_x{1, 0, 0, 0};
+        return {1, 0, 0, 0};
-        return unit_x;
     }
 
     template < typename T >
-    const vec4<T>& vec4<T>::unit_y() noexcept {
+    constexpr vec4<T> vec4<T>::unit_y() noexcept {
-        static const vec4<T> unit_y{0, 1, 0, 0};
+        return {0, 1, 0, 0};
-        return unit_y;
     }
 
     template < typename T >
-    const vec4<T>& vec4<T>::unit_z() noexcept {
+    constexpr vec4<T> vec4<T>::unit_z() noexcept {
-        static const vec4<T> unit_z{0, 0, 1, 0};
+        return {0, 0, 1, 0};
-        return unit_z;
     }
 
     template < typename T >
-    const vec4<T>& vec4<T>::unit_w() noexcept {
+    constexpr vec4<T> vec4<T>::unit_w() noexcept {
-        static const vec4<T> unit_w{0, 0, 0, 1};
+        return {0, 0, 0, 1};
-        return unit_w;
     }
 
     template < typename T >
-    vec4<T>::vec4(T v) noexcept
+    constexpr vec4<T>::vec4(T v) noexcept
     : x(v)
     , y(v)
     , z(v)
     , w(v) {}
 
     template < typename T >
-    vec4<T>::vec4(T nx, T ny, T nz, T nw) noexcept
+    constexpr vec4<T>::vec4(T nx, T ny, T nz, T nw) noexcept
     : x(nx)
     , y(ny)
     , z(nz)
     , w(nw) {}
 
     template < typename T >
-    vec4<T>::vec4(const vec2<T>& other, T nz, T nw) noexcept
+    constexpr vec4<T>::vec4(const vec2<T>& other, T nz, T nw) noexcept
     : x(other.x)
     , y(other.y)
     , z(nz)
     , w(nw) {}
 
     template < typename T >
-    vec4<T>::vec4(const vec3<T>& other, T nw) noexcept
+    constexpr vec4<T>::vec4(const vec3<T>& other, T nw) noexcept
     : x(other.x)
     , y(other.y)
     , z(other.z)
@@ -246,22 +240,22 @@ namespace e2d
     //
 
     template < typename T >
-    vec4<T> make_vec4(T v) noexcept {
+    constexpr vec4<T> make_vec4(T v) noexcept {
         return vec4<T>(v);
     }
 
     template < typename T >
-    vec4<T> make_vec4(T x, T y, T z, T w) noexcept {
+    constexpr vec4<T> make_vec4(T x, T y, T z, T w) noexcept {
         return vec4<T>(x, y, z, w);
     }
 
     template < typename T >
-    vec4<T> make_vec4(const vec2<T>& other, T z, T w) noexcept {
+    constexpr vec4<T> make_vec4(const vec2<T>& other, T z, T w) noexcept {
         return vec4<T>(other, z, w);
     }
 
     template < typename T >
-    vec4<T> make_vec4(const vec3<T>& other, T w) noexcept {
+    constexpr vec4<T> make_vec4(const vec3<T>& other, T w) noexcept {
         return vec4<T>(other, w);
     }
 

sources/enduro2d/high/bindings/math_binds.cpp

@@ -29,10 +29,26 @@ namespace
             sol::meta_function::less_than_or_equal_to, sol::resolve<bool(const vec2<T>&, const vec2<T>&)>(::operator<=),
 
             sol::meta_function::unary_minus, sol::resolve<vec2<T>(const vec2<T>&)>(::operator-),
-            sol::meta_function::addition, sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator+),
+
-            sol::meta_function::subtraction, sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator-),
+            sol::meta_function::addition, sol::overload(
-            sol::meta_function::multiplication, sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator*),
+                sol::resolve<vec2<T>(T, const vec2<T>&)>(::operator+),
-            sol::meta_function::division, sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator/),
+                sol::resolve<vec2<T>(const vec2<T>&, T)>(::operator+),
+                sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator+)),
+
+            sol::meta_function::subtraction, sol::overload(
+                sol::resolve<vec2<T>(T, const vec2<T>&)>(::operator-),
+                sol::resolve<vec2<T>(const vec2<T>&, T)>(::operator-),
+                sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator-)),
+
+            sol::meta_function::multiplication, sol::overload(
+                sol::resolve<vec2<T>(T, const vec2<T>&)>(::operator*),
+                sol::resolve<vec2<T>(const vec2<T>&, T)>(::operator*),
+                sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator*)),
+
+            sol::meta_function::division, sol::overload(
+                sol::resolve<vec2<T>(T, const vec2<T>&)>(::operator/),
+                sol::resolve<vec2<T>(const vec2<T>&, T)>(::operator/),
+                sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&)>(::operator/)),
 
             "approximately", [](const vec2<T>& l, const vec2<T>& r){ return math::approximately(l,r); },
 
@@ -82,16 +98,35 @@ namespace
             sol::meta_function::less_than_or_equal_to, sol::resolve<bool(const vec3<T>&, const vec3<T>&)>(::operator<=),
 
             sol::meta_function::unary_minus, sol::resolve<vec3<T>(const vec3<T>&)>(::operator-),
-            sol::meta_function::addition, sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator+),
+
-            sol::meta_function::subtraction, sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator-),
+            sol::meta_function::addition, sol::overload(
-            sol::meta_function::multiplication, sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator*),
+                sol::resolve<vec3<T>(T, const vec3<T>&)>(::operator+),
-            sol::meta_function::division, sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator/),
+                sol::resolve<vec3<T>(const vec3<T>&, T)>(::operator+),
+                sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator+)),
+
+            sol::meta_function::subtraction, sol::overload(
+                sol::resolve<vec3<T>(T, const vec3<T>&)>(::operator-),
+                sol::resolve<vec3<T>(const vec3<T>&, T)>(::operator-),
+                sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator-)),
+
+            sol::meta_function::multiplication, sol::overload(
+                sol::resolve<vec3<T>(T, const vec3<T>&)>(::operator*),
+                sol::resolve<vec3<T>(const vec3<T>&, T)>(::operator*),
+                sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator*),
+                sol::resolve<vec3<T>(const vec3<T>&, const quat<T>&)>(::operator*)),
+
+            sol::meta_function::division, sol::overload(
+                sol::resolve<vec3<T>(T, const vec3<T>&)>(::operator/),
+                sol::resolve<vec3<T>(const vec3<T>&, T)>(::operator/),
+                sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(::operator/)),
 
             "approximately", [](const vec3<T>& l, const vec3<T>& r){ return math::approximately(l,r); },
 
             "dot", sol::resolve<T(const vec3<T>&, const vec3<T>&)>(&math::dot),
             "abs_dot", sol::resolve<T(const vec3<T>&, const vec3<T>&)>(&math::abs_dot),
 
+            "cross", sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&)>(&math::cross),
+
             "length_squared", sol::resolve<T(const vec3<T>&)>(&math::length_squared),
             "length", sol::resolve<T(const vec3<T>&)>(&math::length),
 
@@ -136,10 +171,26 @@ namespace
             sol::meta_function::less_than_or_equal_to, sol::resolve<bool(const vec4<T>&, const vec4<T>&)>(::operator<=),
 
             sol::meta_function::unary_minus, sol::resolve<vec4<T>(const vec4<T>&)>(::operator-),
-            sol::meta_function::addition, sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator+),
+
-            sol::meta_function::subtraction, sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator-),
+            sol::meta_function::addition, sol::overload(
-            sol::meta_function::multiplication, sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator*),
+                sol::resolve<vec4<T>(T, const vec4<T>&)>(::operator+),
-            sol::meta_function::division, sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator/),
+                sol::resolve<vec4<T>(const vec4<T>&, T)>(::operator+),
+                sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator+)),
+
+            sol::meta_function::subtraction, sol::overload(
+                sol::resolve<vec4<T>(T, const vec4<T>&)>(::operator-),
+                sol::resolve<vec4<T>(const vec4<T>&, T)>(::operator-),
+                sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator-)),
+
+            sol::meta_function::multiplication, sol::overload(
+                sol::resolve<vec4<T>(T, const vec4<T>&)>(::operator*),
+                sol::resolve<vec4<T>(const vec4<T>&, T)>(::operator*),
+                sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator*)),
+
+            sol::meta_function::division, sol::overload(
+                sol::resolve<vec4<T>(T, const vec4<T>&)>(::operator/),
+                sol::resolve<vec4<T>(const vec4<T>&, T)>(::operator/),
+                sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&)>(::operator/)),
 
             "approximately", [](const vec4<T>& l, const vec4<T>& r){ return math::approximately(l,r); },
 
@@ -168,6 +219,97 @@ namespace
 
             "contains_nan", sol::resolve<bool(const vec4<T>&)>(&math::contains_nan));
     }
+
+    template < typename T >
+    void bind_quat(const str& name, sol::state& l) {
+        l.new_usertype<quat<T>>(name,
+            sol::constructors<
+                quat<T>(),
+                quat<T>(quat<T>),
+                quat<T>(T,T,T,T),
+                quat<T>(vec4<T>)>(),
+
+            "x", &quat<T>::x,
+            "y", &quat<T>::y,
+            "z", &quat<T>::z,
+            "w", &quat<T>::w,
+
+            sol::meta_function::equal_to, sol::resolve<bool(const quat<T>&, const quat<T>&)>(::operator==),
+            sol::meta_function::less_than, sol::resolve<bool(const quat<T>&, const quat<T>&)>(::operator<),
+            sol::meta_function::less_than_or_equal_to, sol::resolve<bool(const quat<T>&, const quat<T>&)>(::operator<=),
+
+            sol::meta_function::addition, sol::overload(
+                sol::resolve<quat<T>(T, const quat<T>&)>(::operator+),
+                sol::resolve<quat<T>(const quat<T>&, T)>(::operator+),
+                sol::resolve<quat<T>(const quat<T>&, const quat<T>&)>(::operator+)),
+
+            sol::meta_function::multiplication, sol::overload(
+                sol::resolve<quat<T>(T, const quat<T>&)>(::operator*),
+                sol::resolve<quat<T>(const quat<T>&, T)>(::operator*),
+                sol::resolve<quat<T>(const quat<T>&, const quat<T>&)>(::operator*)),
+
+            "make_quat_from_axis_angle", sol::overload(
+                sol::resolve<quat<T>(const deg<T>&, const vec3<T>&)>(&math::make_quat_from_axis_angle),
+                sol::resolve<quat<T>(const rad<T>&, const vec3<T>&)>(&math::make_quat_from_axis_angle)),
+
+            "make_quat_from_euler_angles", sol::overload(
+                sol::resolve<quat<T>(const deg<T>&, const deg<T>&, const deg<T>&)>(&math::make_quat_from_euler_angles),
+                sol::resolve<quat<T>(const rad<T>&, const rad<T>&, const rad<T>&)>(&math::make_quat_from_euler_angles)),
+
+            "approximately", [](const quat<T>& l, const quat<T>& r){ return math::approximately(l,r); },
+
+            "dot", sol::resolve<T(const quat<T>&, const quat<T>&)>(&math::dot),
+            "abs_dot", sol::resolve<T(const quat<T>&, const quat<T>&)>(&math::abs_dot),
+
+            "length_squared", sol::resolve<T(const quat<T>&)>(&math::length_squared),
+            "length", sol::resolve<T(const quat<T>&)>(&math::length),
+
+            "normalized", [](const quat<T>& v){ return math::normalized(v); },
+
+            "lerp", sol::resolve<quat<T>(const quat<T>&, const quat<T>&, T)>(&math::lerp),
+
+            "inversed", [](const quat<T>& v){ return math::inversed(v); },
+            "conjugated", [](const quat<T>& v){ return math::conjugated(v); },
+
+            "contains_nan", sol::resolve<bool(const quat<T>&)>(&math::contains_nan));
+    }
+
+    template < typename T, typename Tag >
+    void bind_unit(const str& name, sol::state& l) {
+        l.new_usertype<unit<T,Tag>>(name,
+            sol::constructors<
+                unit<T,Tag>(),
+                unit<T,Tag>(T),
+                unit<T,Tag>(unit<T,Tag>)>(),
+
+            "value", &unit<T,Tag>::value,
+
+            sol::meta_function::equal_to, sol::resolve<bool(const unit<T,Tag>&, const unit<T,Tag>&)>(::operator==),
+            sol::meta_function::less_than, sol::resolve<bool(const unit<T,Tag>&, const unit<T,Tag>&)>(::operator<),
+            sol::meta_function::less_than_or_equal_to, sol::resolve<bool(const unit<T,Tag>&, const unit<T,Tag>&)>(::operator<=),
+
+            sol::meta_function::unary_minus, sol::resolve<unit<T,Tag>(const unit<T,Tag>&)>(::operator-),
+
+            sol::meta_function::multiplication, sol::overload(
+                sol::resolve<unit<T,Tag>(T, const unit<T,Tag>&)>(::operator*),
+                sol::resolve<unit<T,Tag>(const unit<T,Tag>&, T)>(::operator*)),
+
+            sol::meta_function::division, sol::overload(
+                sol::resolve<unit<T,Tag>(T, const unit<T,Tag>&)>(::operator/),
+                sol::resolve<unit<T,Tag>(const unit<T,Tag>&, T)>(::operator/)),
+
+            sol::meta_function::addition, sol::resolve<unit<T,Tag>(const unit<T,Tag>&, const unit<T,Tag>&)>(::operator+),
+            sol::meta_function::subtraction, sol::resolve<unit<T,Tag>(const unit<T,Tag>&, const unit<T,Tag>&)>(::operator-),
+
+            "approximately", [](const unit<T,Tag>& l, const unit<T,Tag>& r){ return math::approximately(l,r); },
+
+            "minimized", sol::resolve<unit<T,Tag>(const unit<T,Tag>&, const unit<T,Tag>&)>(&math::minimized),
+            "maximized", sol::resolve<unit<T,Tag>(const unit<T,Tag>&, const unit<T,Tag>&)>(&math::maximized),
+            "clamped", sol::resolve<unit<T,Tag>(const unit<T,Tag>&, const unit<T,Tag>&, const unit<T,Tag>&)>(&math::clamped),
+            "saturated", sol::resolve<unit<T,Tag>(const unit<T,Tag>&)>(&math::saturated),
+
+            "contains_nan", sol::resolve<bool(const unit<T,Tag>&)>(&math::contains_nan));
+    }
 }
 
 namespace e2d::bindings
@@ -176,5 +318,8 @@ namespace e2d::bindings
         bind_vec2<f32>("v2f", l);
         bind_vec3<f32>("v3f", l);
         bind_vec4<f32>("v4f", l);
+        bind_quat<f32>("q4f", l);
+        bind_unit<f32, deg_tag>("degf", l);
+        bind_unit<f32, rad_tag>("radf", l);
     }
 }

untests/sources/untests_high/luasol.cpp

@@ -27,21 +27,29 @@ namespace
 TEST_CASE("luasol") {
     safe_starter_initializer initializer;
     luasol& l = the<luasol>();
+
     SECTION("vec2/vec3/vec4") {
         v2f r0 = l.lua().script(R"lua(
             local v = v2f.new(1,2)
-            return v2f.new((v + v).y)
+            return v2f.new((v + v + 2).y)
         )lua");
         v3f r1 = l.lua().script(R"lua(
             local v = v3f.new(1,2,3)
-            return v3f.new((v + v).y)
+            return v3f.new((v + v + 2).y)
         )lua");
         v4f r2 = l.lua().script(R"lua(
             local v = v4f.new(1,2,3,4)
-            return v4f.new((v + v).y)
+            return v4f.new((v + v + 2).y)
         )lua");
-        REQUIRE(r0 == v2f(4));
+        REQUIRE(r0 == v2f(6));
-        REQUIRE(r1 == v3f(4));
+        REQUIRE(r1 == v3f(6));
-        REQUIRE(r2 == v4f(4));
+        REQUIRE(r2 == v4f(6));
+    }
+
+    SECTION("quat") {
+        v3f r0 = l.lua().script(R"lua(
+            return v3f.new(1,2,3) * q4f.make_quat_from_axis_angle(radf.new(10), v3f.new(1,2,3))
+        )lua");
+        REQUIRE(r0 == v3f(1,2,3) * math::make_quat_from_axis_angle(radf(10.f), v3f(1,2,3)));
     }
 }