remove degf and radf from lua api

samples/bin/library/scripts/emmy/math/degf.lua

@@ -1,46 +0,0 @@
----@class degf
-local degf = {
-    ---@type number
-    value = 0
-}
-
----@overload fun(): degf
----@overload fun(v: number): degf
----@overload fun(u: degf): degf
----@return degf
-function degf.new(...) end
-
----@return degf
-function degf.zero() end
-
----@param l degf
----@param r degf
----@return boolean
-function degf.approximately(l, r) end
-
----@param v degf
----@param vmin degf
----@return degf
-function degf.minimized(v,vmin) end
-
----@param v degf
----@param vmax degf
----@return degf
-function degf.maximized(v,vmax) end
-
----@param v degf
----@param vmin degf
----@param vmax degf
----@return degf
-function degf.clamped(v,vmin,vmax) end
-
----@param v degf
----@return degf
-function degf.saturated(v) end
-
----@param v degf
----@return boolean
-function degf.contains_nan(v) end
-
----@type degf
-_G.degf = _G.degf or degf

samples/bin/library/scripts/emmy/math/m2f.lua

@@ -22,7 +22,7 @@ function m2f.identity() end
 ---@return m2f
 function m2f.make_scale(...) end
 
----@param a degf | radf
+---@param a number
 ---@return m2f
 function m2f.make_rotation(a) end
 

samples/bin/library/scripts/emmy/math/m3f.lua

@@ -22,10 +22,10 @@ function m3f.identity() end
 ---@return m3f
 function m3f.make_scale(...) end
 
----@overload fun(a: degf | radf, x: number, y: number, z: number): m3f
----@overload fun(a: degf | radf, xyz: v4f): m3f
----@overload fun(a: degf | radf, xyz: v3f): m3f
----@overload fun(a: degf | radf, xy: v2f, z: number): m3f
+---@overload fun(a: number, x: number, y: number, z: number): m3f
+---@overload fun(a: number, xyz: v4f): m3f
+---@overload fun(a: number, xyz: v3f): m3f
+---@overload fun(a: number, xy: v2f, z: number): m3f
 ---@overload fun(q: q4f): m3f
 ---@return m3f
 function m3f.make_rotation(...) end

samples/bin/library/scripts/emmy/math/m4f.lua

@@ -29,10 +29,10 @@ function m4f.make_scale(...) end
 ---@return m4f
 function m4f.make_translation(...) end
 
----@overload fun(a: degf | radf, x: number, y: number, z: number): m4f
----@overload fun(a: degf | radf, xyz: v4f): m4f
----@overload fun(a: degf | radf, xyz: v3f): m4f
----@overload fun(a: degf | radf, xy: v2f, z: number): m4f
+---@overload fun(a: number, x: number, y: number, z: number): m4f
+---@overload fun(a: number, xyz: v4f): m4f
+---@overload fun(a: number, xyz: v3f): m4f
+---@overload fun(a: number, xy: v2f, z: number): m4f
 ---@overload fun(q: q4f): m4f
 ---@return m4f
 function m4f.make_rotation(...) end
@@ -63,14 +63,14 @@ function m4f.make_orthogonal_lh(...) end
 ---@return m4f
 function m4f.make_orthogonal_rh(...) end
 
----@param angle degf | radf
+---@param angle number
 ---@param aspect number
 ---@param znear number
 ---@param zfar number
 ---@return m4f
 function m4f.make_perspective_lh(angle, aspect, znear, zfar) end
 
----@param angle degf | radf
+---@param angle number
 ---@param aspect number
 ---@param znear number
 ---@param zfar number

samples/bin/library/scripts/emmy/math/q4f.lua

@@ -26,14 +26,14 @@ function q4f.zero() end
 ---@return q4f
 function q4f.identity() end
 
----@param angle degf | radf
+---@param angle number
 ---@param axis v3f
 ---@return q4f
 function q4f.make_from_axis_angle(angle, axis) end
 
----@param roll degf | radf
----@param pitch degf | radf
----@param yaw degf | radf
+---@param roll number
+---@param pitch number
+---@param yaw number
 ---@return q4f
 function q4f.make_from_euler_angles(roll, pitch, yaw) end
 

samples/bin/library/scripts/emmy/math/radf.lua

@@ -1,46 +0,0 @@
----@class radf
-local radf = {
-    ---@type number
-    value = 0
-}
-
----@overload fun(): radf
----@overload fun(v: number): radf
----@overload fun(u: radf): radf
----@return radf
-function radf.new(...) end
-
----@return radf
-function radf.zero() end
-
----@param l radf
----@param r radf
----@return boolean
-function radf.approximately(l, r) end
-
----@param v radf
----@param vmin radf
----@return radf
-function radf.minimized(v,vmin) end
-
----@param v radf
----@param vmax radf
----@return radf
-function radf.maximized(v,vmax) end
-
----@param v radf
----@param vmin radf
----@param vmax radf
----@return radf
-function radf.clamped(v,vmin,vmax) end
-
----@param v radf
----@return radf
-function radf.saturated(v) end
-
----@param v radf
----@return boolean
-function radf.contains_nan(v) end
-
----@type radf
-_G.radf = _G.radf or radf

samples/bin/library/scripts/emmy/math/t2f.lua

@@ -3,18 +3,16 @@ local t2f = {
     ---@type v2f
     translation = v2f.zero(),
 
-    ---@type radf
-    rotation = radf.zero(),
+    ---@type number
+    rotation = 0,
 
     ---@type v2f
     scale = v2f.unit()
 }
 
 ---@overload fun(): t2f
----@overload fun(t: t2f): t2f
----@overload fun(t: v2f, r: degf | radf, s: v2f): t2f
 ---@return t2f
-function t2f.new(...) end
+function t2f.new() end
 
 ---@return t2f
 function t2f.zero() end
@@ -26,7 +24,7 @@ function t2f.identity() end
 ---@return t2f
 function t2f.make_translation(t) end
 
----@param r degf | radf
+---@param r number
 ---@return t2f
 function t2f.make_rotation(r) end
 

samples/bin/library/scripts/emmy/math/t3f.lua

@@ -11,10 +11,8 @@ local t3f = {
 }
 
 ---@overload fun(): t3f
----@overload fun(t: t3f): t3f
----@overload fun(t: v3f, r: q4f, s: v3f): t3f
 ---@return t3f
-function t3f.new(...) end
+function t3f.new() end
 
 ---@return t3f
 function t3f.zero() end

samples/bin/library/scripts/sample_07/gnome.lua

@@ -10,7 +10,8 @@
 ---@param meta gnome_meta
 ---@param go gobject
 local function update_life_time(meta, go)
-    meta.life_time = meta.life_time - the_engine.delta_time
+    local dt = the_engine.delta_time
+    meta.life_time = meta.life_time - dt
     if meta.life_time <= 0 then
         go:destroy()
     end
@@ -19,10 +20,8 @@ end
 ---@param meta gnome_meta
 ---@param go gobject
 local function update_gnome_rotation(meta, go)
-    go.actor.node.rotation = q4f.make_from_euler_angles(
-        radf.new(),
-        radf.new(the_engine.time),
-        radf.new())
+    local time = the_engine.time
+    go.actor.node.rotation = q4f.make_from_euler_angles(0, time, 0)
 end
 
 -- -----------------------------------------------------------------------------

sources/enduro2d/high/bindings/math_binds/_math_binds.hpp

@@ -25,8 +25,6 @@ namespace e2d::bindings::math
 
     void bind_trs2(sol::state& l);
     void bind_trs3(sol::state& l);
-
-    void bind_unit(sol::state& l);
 }
 
 namespace e2d::bindings
@@ -47,7 +45,5 @@ namespace e2d::bindings
 
         math::bind_trs2(l);
         math::bind_trs3(l);
-
-        math::bind_unit(l);
     }
 }

sources/enduro2d/high/bindings/math_binds/mat2_binds.cpp

@@ -46,16 +46,26 @@ namespace
                 sol::resolve<mat2<T>(const vec3<T>&)>(&math::make_scale_matrix2),
                 sol::resolve<mat2<T>(const vec2<T>&)>(&math::make_scale_matrix2)),
 
-            "make_rotation", sol::overload(
-                sol::resolve<mat2<T>(const deg<T>&)>(&math::make_rotation_matrix2),
-                sol::resolve<mat2<T>(const rad<T>&)>(&math::make_rotation_matrix2)),
+            "make_rotation", [](T angle) -> mat2<T> {
+                return math::make_rotation_matrix2(make_rad(angle));
+            },
 
-            "approximately", [](const mat2<T>& l, const mat2<T>& r){ return math::approximately(l,r); },
+            "approximately", [](const mat2<T>& l, const mat2<T>& r) -> bool {
+                return math::approximately(l,r);
+            },
 
-            "inversed", [](const mat2<T>& m){ return math::inversed(m); },
-            "transposed", [](const mat2<T>& m){ return math::transposed(m); },
+            "inversed", [](const mat2<T>& m) -> std::pair<mat2<T>, bool> {
+                return math::inversed(m);
+            },
 
-            "contains_nan", sol::resolve<bool(const mat2<T>&)>(&math::contains_nan));
+            "transposed", [](const mat2<T>& m) -> mat2<T> {
+                return math::transposed(m);
+            },
+
+            "contains_nan", [](const mat2<T>& m) -> bool {
+                return math::contains_nan(m);
+            }
+        );
     }
 }
 

sources/enduro2d/high/bindings/math_binds/mat3_binds.cpp

@@ -47,22 +47,28 @@ namespace
                 sol::resolve<mat3<T>(const vec2<T>&, T)>(&math::make_scale_matrix3)),
 
             "make_rotation", sol::overload(
-                sol::resolve<mat3<T>(const deg<T>&,T,T,T)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const deg<T>&,const vec4<T>&)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const deg<T>&,const vec3<T>&)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const deg<T>&,const vec2<T>&,T)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const rad<T>&,T,T,T)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const rad<T>&,const vec4<T>&)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const rad<T>&,const vec3<T>&)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const rad<T>&,const vec2<T>&,T)>(&math::make_rotation_matrix3),
-                sol::resolve<mat3<T>(const quat<T>&)>(&math::make_rotation_matrix3)),
+                [](T angle, T x, T y, T z) -> mat3<T> { return math::make_rotation_matrix3(make_rad(angle), x, y, z); },
+                [](T angle, const vec4<T>& xyz) -> mat3<T> { return math::make_rotation_matrix3(make_rad(angle), xyz); },
+                [](T angle, const vec3<T>& xyz) -> mat3<T> { return math::make_rotation_matrix3(make_rad(angle), xyz); },
+                [](T angle, const vec2<T>& xy, T z) -> mat3<T> { return math::make_rotation_matrix3(make_rad(angle), xy, z); },
+                [](const quat<T>& q) -> mat3<T> { return math::make_rotation_matrix3(q); }),
 
-            "approximately", [](const mat3<T>& l, const mat3<T>& r){ return math::approximately(l,r); },
+            "approximately", [](const mat3<T>& l, const mat3<T>& r) -> bool {
+                return math::approximately(l,r);
+            },
 
-            "inversed", [](const mat3<T>& m){ return math::inversed(m); },
-            "transposed", [](const mat3<T>& m){ return math::transposed(m); },
+            "inversed", [](const mat3<T>& m) -> std::pair<mat3<T>, bool> {
+                return math::inversed(m);
+            },
 
-            "contains_nan", sol::resolve<bool(const mat3<T>&)>(&math::contains_nan));
+            "transposed", [](const mat3<T>& m) -> mat3<T> {
+                return math::transposed(m);
+            },
+
+            "contains_nan", [](const mat3<T>& m) -> bool {
+                return math::contains_nan(m);
+            }
+        );
     }
 }
 

sources/enduro2d/high/bindings/math_binds/mat4_binds.cpp

@@ -53,15 +53,11 @@ namespace
                 sol::resolve<mat4<T>(const vec2<T>&, T)>(&math::make_translation_matrix4)),
 
             "make_rotation", sol::overload(
-                sol::resolve<mat4<T>(const deg<T>&,T,T,T)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const deg<T>&,const vec4<T>&)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const deg<T>&,const vec3<T>&)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const deg<T>&,const vec2<T>&,T)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const rad<T>&,T,T,T)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const rad<T>&,const vec4<T>&)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const rad<T>&,const vec3<T>&)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const rad<T>&,const vec2<T>&,T)>(&math::make_rotation_matrix4),
-                sol::resolve<mat4<T>(const quat<T>&)>(&math::make_rotation_matrix4)),
+                [](T angle, T x, T y, T z) -> mat4<T> { return math::make_rotation_matrix4(make_rad(angle), x, y, z); },
+                [](T angle, const vec4<T>& xyz) -> mat4<T> { return math::make_rotation_matrix4(make_rad(angle), xyz); },
+                [](T angle, const vec3<T>& xyz) -> mat4<T> { return math::make_rotation_matrix4(make_rad(angle), xyz); },
+                [](T angle, const vec2<T>& xy, T z) -> mat4<T> { return math::make_rotation_matrix4(make_rad(angle), xy, z); },
+                [](const quat<T>& q) -> mat4<T> { return math::make_rotation_matrix4(q); }),
 
             "make_trs", sol::overload(
                 sol::resolve<mat4<T>(const trs2<T>&)>(&math::make_trs_matrix4),
@@ -81,20 +77,30 @@ namespace
                 sol::resolve<mat4<T>(T,T,T,T)>(&math::make_orthogonal_rh_matrix4),
                 sol::resolve<mat4<T>(const vec2<T>&,T,T)>(&math::make_orthogonal_rh_matrix4)),
 
-            "make_perspective_lh", sol::overload(
-                sol::resolve<mat4<T>(const degf&,T,T,T)>(&math::make_perspective_lh_matrix4),
-                sol::resolve<mat4<T>(const radf&,T,T,T)>(&math::make_perspective_lh_matrix4)),
+            "make_perspective_lh", [](T angle, T aspect, T znear, T zfar) -> mat4<T> {
+                return math::make_perspective_lh_matrix4(make_rad(angle), aspect, znear, zfar);
+            },
 
-            "make_perspective_rh", sol::overload(
-                sol::resolve<mat4<T>(const degf&,T,T,T)>(&math::make_perspective_rh_matrix4),
-                sol::resolve<mat4<T>(const radf&,T,T,T)>(&math::make_perspective_rh_matrix4)),
+            "make_perspective_rh", [](T angle, T aspect, T znear, T zfar) -> mat4<T> {
+                return math::make_perspective_rh_matrix4(make_rad(angle), aspect, znear, zfar);
+            },
 
-            "approximately", [](const mat4<T>& l, const mat4<T>& r){ return math::approximately(l,r); },
+            "approximately", [](const mat4<T>& l, const mat4<T>& r) -> bool {
+                return math::approximately(l,r);
+            },
 
-            "inversed", [](const mat4<T>& m){ return math::inversed(m); },
-            "transposed", [](const mat4<T>& m){ return math::transposed(m); },
+            "inversed", [](const mat4<T>& m) -> std::pair<mat4<T>, bool> {
+                return math::inversed(m);
+            },
 
-            "contains_nan", sol::resolve<bool(const mat4<T>&)>(&math::contains_nan));
+            "transposed", [](const mat4<T>& m) -> mat4<T> {
+                return math::transposed(m);
+            },
+
+            "contains_nan", [](const mat4<T>& m) -> bool {
+                return math::contains_nan(m);
+            }
+        );
     }
 }
 

sources/enduro2d/high/bindings/math_binds/quat_binds.cpp

@@ -45,13 +45,13 @@ namespace
                 sol::resolve<quat<T>(const quat<T>&, T)>(::operator*),
                 sol::resolve<quat<T>(const quat<T>&, const quat<T>&)>(::operator*)),
 
-            "make_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_from_axis_angle", [](T angle, const vec3<T>& xyz) -> quat<T> {
+                return math::make_quat_from_axis_angle(make_rad(angle), xyz);
+            },
 
-            "make_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)),
+            "make_from_euler_angles", [](T roll, T pitch, T yaw) -> quat<T> {
+                return math::make_quat_from_euler_angles(make_rad(roll), make_rad(pitch), make_rad(yaw));
+            },
 
             "approximately", [](const quat<T>& l, const quat<T>& r){ return math::approximately(l,r); },
 

sources/enduro2d/high/bindings/math_binds/trs2_binds.cpp

@@ -13,17 +13,15 @@ namespace
     template < typename T >
     void bind_trs2_t(const str& name, sol::state& l) {
         l.new_usertype<trs2<T>>(name,
-            sol::constructors<
-                trs2<T>(),
-                trs2<T>(trs2<T>),
-                trs2<T>(vec2<T>,deg<T>,vec2<T>),
-                trs2<T>(vec2<T>,rad<T>,vec2<T>)>(),
+            sol::no_constructor,
 
             "zero", &trs2<T>::zero,
             "identity", &trs2<T>::identity,
 
             "translation", &trs2<T>::translation,
-            "rotation", &trs2<T>::rotation,
+            "rotation", sol::property(
+                [](const trs2<T>& t){ return t.rotation.value; },
+                [](trs2<T>& t, T v){ t.rotation.value = v; }),
             "scale", &trs2<T>::scale,
 
             sol::meta_function::to_string, [](const trs2<T>& v){
@@ -32,14 +30,26 @@ namespace
 
             sol::meta_function::equal_to, sol::resolve<bool(const trs2<T>&, const trs2<T>&)>(::operator==),
 
-            "make_translation", sol::resolve<trs2<T>(const vec2<T>&)>(&math::make_translation_trs2),
-            "make_rotation", sol::overload(
-                sol::resolve<trs2<T>(const deg<T>&)>(&math::make_rotation_trs2),
-                sol::resolve<trs2<T>(const rad<T>&)>(&math::make_rotation_trs2)),
-            "make_scale", sol::resolve<trs2<T>(const vec2<T>&)>(&math::make_scale_trs2),
+            "make_translation", [](const vec2<T>& t) -> trs2<T> {
+                return math::make_translation_trs2(t);
+            },
 
-            "approximately", [](const trs2<T>& l, const trs2<T>& r){ return math::approximately(l,r); },
-            "contains_nan", sol::resolve<bool(const trs2<T>&)>(&math::contains_nan));
+            "make_rotation", [](T angle) -> trs2<T> {
+                return math::make_rotation_trs2(make_rad(angle));
+            },
+
+            "make_scale", [](const vec2<T>& s) -> trs2<T> {
+                return math::make_scale_trs2(s);
+            },
+
+            "approximately", [](const trs2<T>& l, const trs2<T>& r) -> bool {
+                return math::approximately(l,r);
+            },
+
+            "contains_nan", [](const trs2<T>& t) -> bool {
+                return math::contains_nan(t);
+            }
+        );
     }
 }
 

sources/enduro2d/high/bindings/math_binds/trs3_binds.cpp

@@ -13,10 +13,7 @@ namespace
     template < typename T >
     void bind_trs3_t(const str& name, sol::state& l) {
         l.new_usertype<trs3<T>>(name,
-            sol::constructors<
-                trs3<T>(),
-                trs3<T>(trs3<T>),
-                trs3<T>(vec3<T>,quat<T>,vec3<T>)>(),
+            sol::no_constructor,
 
             "zero", &trs3<T>::zero,
             "identity", &trs3<T>::identity,
@@ -31,12 +28,26 @@ namespace
 
             sol::meta_function::equal_to, sol::resolve<bool(const trs3<T>&, const trs3<T>&)>(::operator==),
 
-            "make_translation", sol::resolve<trs3<T>(const vec3<T>&)>(&math::make_translation_trs3),
-            "make_rotation", sol::resolve<trs3<T>(const quat<T>&)>(&math::make_rotation_trs3),
-            "make_scale", sol::resolve<trs3<T>(const vec3<T>&)>(&math::make_scale_trs3),
+            "make_translation", [](const vec3<T>& t) -> trs3<T> {
+                return math::make_translation_trs3(t);
+            },
 
-            "approximately", [](const trs3<T>& l, const trs3<T>& r){ return math::approximately(l,r); },
-            "contains_nan", sol::resolve<bool(const trs3<T>&)>(&math::contains_nan));
+            "make_rotation", [](const quat<T>& q) -> trs3<T> {
+                return math::make_rotation_trs3(q);
+            },
+
+            "make_scale", [](const vec3<T>& s) -> trs3<T> {
+                return math::make_scale_trs3(s);
+            },
+
+            "approximately", [](const trs3<T>& l, const trs3<T>& r) -> bool {
+                return math::approximately(l,r);
+            },
+
+            "contains_nan", [](const trs3<T>& t) -> bool {
+                return math::contains_nan(t);
+            }
+        );
     }
 }
 

sources/enduro2d/high/bindings/math_binds/unit_binds.cpp

@@ -1,63 +0,0 @@
-/*******************************************************************************
- * This file is part of the "Enduro2D"
- * For conditions of distribution and use, see copyright notice in LICENSE.md
- * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
- ******************************************************************************/
-
-#include "_math_binds.hpp"
-
-namespace
-{
-    using namespace e2d;
-
-    template < typename T, typename Tag >
-    void bind_unit_t(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>)>(),
-
-            "zero", &unit<T,Tag>::zero,
-
-            "value", &unit<T,Tag>::value,
-
-            sol::meta_function::to_string, [](const unit<T,Tag>& v){
-                return strings::rformat("%0", v);
-            },
-
-            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::math
-{
-    void bind_unit(sol::state& l) {
-        bind_unit_t<f32, deg_tag>("degf", l);
-        bind_unit_t<f32, rad_tag>("radf", l);
-    }
-}

untests/sources/untests_high/luasol.cpp

@@ -55,7 +55,7 @@ TEST_CASE("luasol") {
     SECTION("quat") {
         v3f r0 = l.with_state([](sol::state& lua){
             return lua.script(R"lua(
-                return v3f.new(1,2,3) * q4f.make_from_axis_angle(radf.new(10), v3f.new(1,2,3))
+                return v3f.new(1,2,3) * q4f.make_from_axis_angle(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)));
@@ -71,7 +71,7 @@ TEST_CASE("luasol") {
         });
         std::pair<m3f, bool> r1 = l.with_state([](sol::state& lua){
             return lua.script(R"lua(
-                local m = m3f.make_rotation(degf.new(45),2,3,4)
+                local m = m3f.make_rotation(45,2,3,4)
                 local rm, s = m3f.inversed(m)
                 return rm * m3f.identity(), s
             )lua");
@@ -86,7 +86,7 @@ TEST_CASE("luasol") {
         REQUIRE(r0.second);
         REQUIRE(r0.first == math::inversed(math::make_scale_matrix2(2.f,3.f)).first);
         REQUIRE(r1.second);
-        REQUIRE(r1.first == math::inversed(math::make_rotation_matrix3(degf(45.f),2.f,3.f,4.f)).first);
+        REQUIRE(r1.first == math::inversed(math::make_rotation_matrix3(radf(45.f),2.f,3.f,4.f)).first);
         REQUIRE(r2.second);
         REQUIRE(r2.first == math::inversed(math::make_translation_matrix4(2.f,3.f,4.f)).first);
     }
@@ -109,13 +109,13 @@ TEST_CASE("luasol") {
     }
 
     SECTION("trs2/trs3") {
-        radf r0 = l.with_state([](sol::state& lua){
+        f32 r0 = l.with_state([](sol::state& lua){
             return lua.script(R"lua(
-                local t = t2f.make_rotation(degf.new(45))
+                local t = t2f.make_rotation(0.5)
                 return t.rotation
             )lua");
         });
-        REQUIRE(r0 == math::to_rad(degf(45.f)));
+        REQUIRE(math::approximately(r0, 0.5f));
         v3f r1 = l.with_state([](sol::state& lua){
             return lua.script(R"lua(
                 local t = t3f.make_translation(v3f.new(1,2,3))