math lua api is almost complete

headers/enduro2d/math/mat4.hpp

@@ -614,7 +614,7 @@ namespace e2d::math
     make_perspective_lh_matrix4(const unit<T, AngleTag>& fov, T aspect, T znear, T zfar) noexcept {
         E2D_ASSERT(!math::is_near_zero(aspect, T(0)));
         E2D_ASSERT(!math::approximately(znear, zfar, T(0)));
-        E2D_ASSERT(!math::approximately(to_rad(fov), make_rad<T>(0), T(0)));
+        E2D_ASSERT(!math::approximately(fov, unit<T, AngleTag>::zero(), T(0)));
         const T sy = T(1) / math::tan(fov * T(0.5));
         const T sx = sy / aspect;
         const T sz = zfar / (zfar - znear);
@@ -635,7 +635,7 @@ namespace e2d::math
     make_perspective_rh_matrix4(const unit<T, AngleTag>& fov, T aspect, T znear, T zfar) noexcept {
         E2D_ASSERT(!math::is_near_zero(aspect, T(0)));
         E2D_ASSERT(!math::approximately(znear, zfar, T(0)));
-        E2D_ASSERT(!math::approximately(to_rad(fov), make_rad<T>(0), T(0)));
+        E2D_ASSERT(!math::approximately(fov, unit<T, AngleTag>::zero(), T(0)));
         const T sy = T(1) / math::tan(fov * T(0.5));
         const T sx = sy / aspect;
         const T sz = zfar / (znear - zfar);

headers/enduro2d/math/trs2.hpp

@@ -23,7 +23,7 @@ namespace e2d
         using value_type = T;
     public:
         vec2<T> translation = vec2<T>::zero();
-        rad<T> rotation = rad<T>(0);
+        rad<T> rotation = rad<T>::zero();
         vec2<T> scale = vec2<T>::unit();
     public:
         static constexpr trs2 zero() noexcept;
@@ -50,7 +50,7 @@ namespace e2d
     constexpr trs2<T> trs2<T>::zero() noexcept {
         return {
             vec2<T>::zero(),
-            rad<T>(0),
+            rad<T>::zero(),
             vec2<T>::zero()};
     }
 
@@ -58,7 +58,7 @@ namespace e2d
     constexpr trs2<T> trs2<T>::identity() noexcept {
         return {
             vec2<T>::zero(),
-            rad<T>(0),
+            rad<T>::zero(),
             vec2<T>::unit()};
     }
 
@@ -118,7 +118,7 @@ namespace e2d::math
 {
     template < typename T >
     trs2<T> make_translation_trs2(const vec2<T>& t) noexcept {
-        return trs2<T>(t, rad<T>(0), vec2<T>::unit());
+        return trs2<T>(t, rad<T>::zero(), vec2<T>::unit());
     }
 
     template < typename T, typename AngleTag >
@@ -128,7 +128,7 @@ namespace e2d::math
 
     template < typename T >
     trs2<T> make_scale_trs2(const vec2<T>& s) noexcept {
-        return trs2<T>(vec2<T>::zero(), rad<T>(0), s);
+        return trs2<T>(vec2<T>::zero(), rad<T>::zero(), s);
     }
 
     template < typename T >

headers/enduro2d/math/unit.hpp

@@ -21,6 +21,8 @@ namespace e2d
         using tag_type = Tag;
     public:
         T value = 0;
+    public:
+        static constexpr unit zero() noexcept;
     public:
         constexpr unit() noexcept = default;
         constexpr unit(const unit& other) noexcept = default;
@@ -59,6 +61,11 @@ namespace e2d
 
 namespace e2d
 {
+    template < typename T, typename Tag >
+    constexpr unit<T, Tag> unit<T, Tag>::zero() noexcept {
+        return unit<T, Tag>(0);
+    }
+
     template < typename T, typename Tag >
     constexpr unit<T, Tag>::unit(T v) noexcept
     : value(v) {}

samples/bin/library/scripts/emmy/core/debug.lua

@@ -1,17 +1,18 @@
 ---@class debug
 local debug = {
-    ---@type fun(self: debug, message: string)
-    trace = function(self, message) end,
-
-    ---@type fun(self: debug, message: string)
-    warning = function(self, message) end,
-
-    ---@type fun(self: debug, message: string)
-    error = function(self, message) end,
-
-    ---@type fun(self: debug, message: string)
-    fatal = function(self, message) end
 }
 
+---@param message string
+function debug:trace(message) end
+
+---@param message string
+function debug:warning(message) end
+
+---@param message string
+function debug:error(message) end
+
+---@param message string
+function debug:fatal(message) end
+
 ---@type debug
 _G.the_debug = _G.the_debug or debug

samples/bin/library/scripts/emmy/core/keyboard.lua

@@ -1,14 +1,5 @@
 ---@class keyboard
 local keyboard = {
-    ---@type fun(self: keyboard, key : string): boolean
-    is_key_pressed = function(self, key) return false end,
-
-    ---@type fun(self: keyboard, key : string): boolean
-    is_key_just_pressed = function(self, key) return false end,
-
-    ---@type fun(self: keyboard, key : string): boolean
-    is_key_just_released = function(self, key) return false end,
-
     ---@type string
     input_text = "",
 
@@ -31,5 +22,17 @@ local keyboard = {
     just_released_keys = {}
 }
 
+---@param key string
+---@return boolean
+function keyboard:is_key_pressed(key) end
+
+---@param key string
+---@return boolean
+function keyboard:is_key_just_pressed(key) end
+
+---@param key string
+---@return boolean
+function keyboard:is_key_just_released(key) end
+
 ---@type keyboard
 _G.the_keyboard = _G.the_keyboard or keyboard

samples/bin/library/scripts/emmy/core/mouse.lua

@@ -1,14 +1,5 @@
 ---@class mouse
 local mouse = {
-    ---@type fun(self: mouse, button : string): boolean
-    is_button_pressed = function(self, button) return false end,
-
-    ---@type fun(self: mouse, button : string): boolean
-    is_button_just_pressed = function(self, button) return false end,
-
-    ---@type fun(self: mouse, button : string): boolean
-    is_button_just_released = function(self, button) return false end,
-
     ---@type v2f
     cursor_pos = v2f.zero(),
 
@@ -34,5 +25,17 @@ local mouse = {
     just_released_buttons = {}
 }
 
+---@param button string
+---@return boolean
+function mouse:is_button_pressed(button) end
+
+---@param button string
+---@return boolean
+function mouse:is_button_just_pressed(button) end
+
+---@param button string
+---@return boolean
+function mouse:is_button_just_released(button) end
+
 ---@type mouse
 _G.the_mouse = _G.the_mouse or mouse

samples/bin/library/scripts/emmy/core/window.lua

@@ -1,17 +1,5 @@
 ---@class window
 local window = {
-    ---@type fun(self: window)
-    hide = function(self) end,
-
-    ---@type fun(self: window)
-    show = function(self) end,
-
-    ---@type fun(self: window)
-    restore = function(self) end,
-
-    ---@type fun(self: window)
-    minimize = function(self) end,
-
     ---@type boolean
     enable = true,
 
@@ -46,5 +34,13 @@ local window = {
     should_close = false
 }
 
+function window:hide() end
+
+function window:show() end
+
+function window:restore() end
+
+function window:minimize() end
+
 ---@type window
 _G.the_window = _G.the_window or window

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

@@ -0,0 +1,83 @@
+---@class aabb
+local aabb = {
+    ---@type v3f
+    position = v3f.zero(),
+
+    ---@type v3f
+    size = v3f.zero()
+}
+
+---@overload fun(): aabb
+---@overload fun(r: aabb): aabb
+---@overload fun(w: number, h: number): aabb
+---@overload fun(x: number, y: number, w: number, h: number): aabb
+---@overload fun(s: v3f): aabb
+---@overload fun(p: v3f, s: v3f): aabb
+---@return aabb
+function aabb.new() end
+
+---@return aabb
+function aabb.zero() end
+
+---@return aabb
+function aabb.unit() end
+
+---@overload fun(r: aabb): aabb
+---@overload fun(x1: number, y1: number, x2: number, y2: number): aabb
+---@overload fun(p1: v3f, p2: v3f): aabb
+---@param r aabb
+---@return aabb
+function aabb.make_minmax(r) end
+
+---@param l aabb
+---@param r aabb
+---@return boolean
+function aabb.approximately(l, r) end
+
+---@param r aabb
+---@return v3f
+function aabb.minimum(r) end
+
+---@param r aabb
+---@return v3f
+function aabb.maximum(r) end
+
+---@param r aabb
+---@return number
+function aabb.volume(r) end
+
+---@param r aabb
+---@return number
+function aabb.abs_volume(r) end
+
+---@param l aabb
+---@param r aabb
+---@return aabb
+function aabb.merged(l, r) end
+
+---@param r aabb
+---@param p v3f
+---@return boolean
+function aabb.inside(r, p) end
+
+---@param l aabb
+---@param r aabb
+---@return boolean
+function aabb.overlaps(l, r) end
+
+---@param r aabb
+---@param p v3f
+---@return v3f
+function aabb.normalized_to_point(r, p) end
+
+---@param r aabb
+---@param p v3f
+---@return v3f
+function aabb.point_to_normalized(r, p) end
+
+---@param r aabb
+---@return boolean
+function aabb.contains_nan(r) end
+
+---@type aabb
+_G.aabb = _G.aabb or aabb

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

@@ -0,0 +1,46 @@
+---@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

@@ -0,0 +1,49 @@
+---@class m2f
+local m2f = {
+    ---@type v2f[]
+    rows = {}
+}
+
+---@overload fun(): m2f
+---@overload fun(r0: v2f, r1: v2f): m2f
+---@return m2f
+function m2f.new() end
+
+---@return m2f
+function m2f.zero() end
+
+---@return m2f
+function m2f.identity() end
+
+---@overload fun(x: number, y: number): m2f
+---@overload fun(xy: v4f): m2f
+---@overload fun(xy: v3f): m2f
+---@overload fun(xy: v2f): m2f
+---@param x number
+---@param y number
+---@return m2f
+function m2f.make_scale(x,y) end
+
+---@param a degf | radf
+---@return m2f
+function m2f.make_rotation(a) end
+
+---@param l m2f
+---@param r m2f
+---@return boolean
+function m2f.approximately(l, r) end
+
+---@param m m2f
+---@return m2f, boolean
+function m2f.inversed(m) end
+
+---@param m m2f
+---@return m2f
+function m2f.transposed(m) end
+
+---@param m m2f
+---@return boolean
+function m2f.contains_nan(m) end
+
+---@type m2f
+_G.m2f = _G.m2f or m2f

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

@@ -0,0 +1,58 @@
+---@class m3f
+local m3f = {
+    ---@type v3f[]
+    rows = {}
+}
+
+---@overload fun(): m3f
+---@overload fun(r0: v3f, r1: v3f, r2: v3f): m3f
+---@return m3f
+function m3f.new() end
+
+---@return m3f
+function m3f.zero() end
+
+---@return m3f
+function m3f.identity() end
+
+---@overload fun(x: number, y: number, z: number): m3f
+---@overload fun(xyz: v4f): m3f
+---@overload fun(xyz: v3f): m3f
+---@overload fun(xy: v2f, z: number): m3f
+---@param x number
+---@param y number
+---@param z number
+---@return m3f
+function m3f.make_scale(x,y,z) 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(q: q4f): m3f
+---@param a degf | radf
+---@param x number
+---@param y number
+---@param z number
+---@return m3f
+function m3f.make_rotation(a,x,y,z) end
+
+---@param l m3f
+---@param r m3f
+---@return boolean
+function m3f.approximately(l, r) end
+
+---@param m m3f
+---@return m3f, boolean
+function m3f.inversed(m) end
+
+---@param m m3f
+---@return m3f
+function m3f.transposed(m) end
+
+---@param m m3f
+---@return boolean
+function m3f.contains_nan(m) end
+
+---@type m3f
+_G.m3f = _G.m3f or m3f

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

@@ -0,0 +1,116 @@
+---@class m4f
+local m4f = {
+    ---@type v4f[]
+    rows = {}
+}
+
+---@overload fun(): m4f
+---@overload fun(r0: v4f, r1: v4f, r2: v4f, r3: v4f): m4f
+---@return m4f
+function m4f.new() end
+
+---@return m4f
+function m4f.zero() end
+
+---@return m4f
+function m4f.identity() end
+
+---@overload fun(x: number, y: number, z: number): m4f
+---@overload fun(xyz: v4f): m4f
+---@overload fun(xyz: v3f): m4f
+---@overload fun(xy: v2f, z: number): m4f
+---@param x number
+---@param y number
+---@param z number
+---@return m4f
+function m4f.make_scale(x,y,z) end
+
+---@overload fun(x: number, y: number, z: number): m4f
+---@overload fun(xyz: v4f): m4f
+---@overload fun(xyz: v3f): m4f
+---@overload fun(xy: v2f, z: number): m4f
+---@param x number
+---@param y number
+---@param z number
+---@return m4f
+function m4f.make_translation(x,y,z) 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(q: q4f): m4f
+---@param a degf | radf
+---@param x number
+---@param y number
+---@param z number
+---@return m4f
+function m4f.make_rotation(a,x,y,z) end
+
+---@param t t2f | t3f
+---@return m4f
+function m4f.make_trs(t) end
+
+---@param eye v3f
+---@param at v3f
+---@param up v3f
+---@return m4f
+function m4f.make_look_at_lh(eye, at, up) end
+
+---@param eye v3f
+---@param at v3f
+---@param up v3f
+---@return m4f
+function m4f.make_look_at_rh(eye, at, up) end
+
+---@type fun(width: number, height: number, znear: number, zfar: number): m4f
+---@overload fun(size: v2f, znear: number, zfar: number): m4f
+---@param width number
+---@param height number
+---@param znear number
+---@param zfar number
+---@return m4f
+function m4f.make_orthogonal_lh(width, height, znear, zfar) end
+
+---@type fun(width: number, height: number, znear: number, zfar: number): m4f
+---@overload fun(size: v2f, znear: number, zfar: number): m4f
+---@param width number
+---@param height number
+---@param znear number
+---@param zfar number
+---@return m4f
+function m4f.make_orthogonal_rh(width, height, znear, zfar) end
+
+---@param angle degf | radf
+---@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 aspect number
+---@param znear number
+---@param zfar number
+---@return m4f
+function m4f.make_perspective_rh(angle, aspect, znear, zfar) end
+
+---@param l m4f
+---@param r m4f
+---@return boolean
+function m4f.approximately(l, r) end
+
+---@param m m4f
+---@return m4f, boolean
+function m4f.inversed(m) end
+
+---@param m m4f
+---@return m4f
+function m4f.transposed(m) end
+
+---@param m m4f
+---@return boolean
+function m4f.contains_nan(m) end
+
+---@type m4f
+_G.m4f = _G.m4f or m4f

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

@@ -0,0 +1,86 @@
+---@class q4f
+local q4f = {
+    ---@type number
+    x = 0,
+
+    ---@type number
+    y = 0,
+
+    ---@type number
+    z = 0,
+
+    ---@type number
+    w = 0
+}
+
+---@overload fun(): q4f
+---@overload fun(q: q4f): q4f
+---@overload fun(x: number, y: number, z: number, w: number): q4f
+---@overload fun(v: v4f): q4f
+---@return q4f
+function q4f.new() end
+
+---@return q4f
+function q4f.zero() end
+
+---@return q4f
+function q4f.identity() end
+
+---@param angle degf | radf
+---@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
+---@return q4f
+function q4f.make_from_euler_angles(roll, pitch, yaw) end
+
+---@param l q4f
+---@param r q4f
+---@return boolean
+function q4f.approximately(l, r) end
+
+---@param l q4f
+---@param r q4f
+---@return number
+function q4f.dot(l, r) end
+
+---@param l q4f
+---@param r q4f
+---@return number
+function q4f.abs_dot(l, r) end
+
+---@param q q4f
+---@return number
+function q4f.length_squared(q) end
+
+---@param q q4f
+---@return number
+function q4f.length(q) end
+
+---@param q q4f
+---@return q4f
+function q4f.normalized(q) end
+
+---@param l q4f
+---@param r q4f
+---@param v number
+---@return q4f
+function q4f.lerp(l, r, v) end
+
+---@param q q4f
+---@return q4f
+function q4f.inversed(q) end
+
+---@param q q4f
+---@return q4f
+function q4f.conjugated(q) end
+
+---@param q q4f
+---@return q4f
+function q4f.contains_nan(q) end
+
+---@type q4f
+_G.q4f = _G.q4f or q4f

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

@@ -0,0 +1,46 @@
+---@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/rect.lua

@@ -0,0 +1,83 @@
+---@class rect
+local rect = {
+    ---@type v2f
+    position = v2f.zero(),
+
+    ---@type v2f
+    size = v2f.zero()
+}
+
+---@overload fun(): rect
+---@overload fun(r: rect): rect
+---@overload fun(w: number, h: number): rect
+---@overload fun(x: number, y: number, w: number, h: number): rect
+---@overload fun(s: v2f): rect
+---@overload fun(p: v2f, s: v2f): rect
+---@return rect
+function rect.new() end
+
+---@return rect
+function rect.zero() end
+
+---@return rect
+function rect.unit() end
+
+---@overload fun(r: rect): rect
+---@overload fun(x1: number, y1: number, x2: number, y2: number): rect
+---@overload fun(p1: v2f, p2: v2f): rect
+---@param r rect
+---@return rect
+function rect.make_minmax(r) end
+
+---@param l rect
+---@param r rect
+---@return boolean
+function rect.approximately(l, r) end
+
+---@param r rect
+---@return v2f
+function rect.minimum(r) end
+
+---@param r rect
+---@return v2f
+function rect.maximum(r) end
+
+---@param r rect
+---@return number
+function rect.area(r) end
+
+---@param r rect
+---@return number
+function rect.abs_area(r) end
+
+---@param l rect
+---@param r rect
+---@return rect
+function rect.merged(l, r) end
+
+---@param r rect
+---@param p v2f
+---@return boolean
+function rect.inside(r, p) end
+
+---@param l rect
+---@param r rect
+---@return boolean
+function rect.overlaps(l, r) end
+
+---@param r rect
+---@param p v2f
+---@return v2f
+function rect.normalized_to_point(r, p) end
+
+---@param r rect
+---@param p v2f
+---@return v2f
+function rect.point_to_normalized(r, p) end
+
+---@param r rect
+---@return boolean
+function rect.contains_nan(r) end
+
+---@type rect
+_G.rect = _G.rect or rect

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

@@ -0,0 +1,47 @@
+---@class t2f
+local t2f = {
+    ---@type v2f
+    translation = v2f.zero(),
+
+    ---@type radf
+    rotation = radf.zero(),
+
+    ---@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
+
+---@return t2f
+function t2f.zero() end
+
+---@return t2f
+function t2f.identity() end
+
+---@param t v2f
+---@return t2f
+function t2f.make_translation(t) end
+
+---@param r degf | radf
+---@return t2f
+function t2f.make_rotation(r) end
+
+---@param s v2f
+---@return t2f
+function t2f.make_scale(s) end
+
+---@param l t2f
+---@param r t2f
+---@return boolean
+function t2f.approximately(l, r) end
+
+---@param t t2f
+---@return boolean
+function t2f.contains_nan(t) end
+
+---@type t2f
+_G.t2f = _G.t2f or t2f

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

@@ -0,0 +1,47 @@
+---@class t3f
+local t3f = {
+    ---@type v3f
+    translation = v3f.zero(),
+
+    ---@type q4f
+    rotation = q4f.identity(),
+
+    ---@type v3f
+    scale = v3f.unit()
+}
+
+---@overload fun(): t3f
+---@overload fun(t: t3f): t3f
+---@overload fun(t: v3f, r: q4f, s: v3f): t3f
+---@return t3f
+function t3f.new() end
+
+---@return t3f
+function t3f.zero() end
+
+---@return t3f
+function t3f.identity() end
+
+---@param t v3f
+---@return t3f
+function t3f.make_translation(t) end
+
+---@param r q4f
+---@return t3f
+function t3f.make_rotation(r) end
+
+---@param s v3f
+---@return t3f
+function t3f.make_scale(s) end
+
+---@param l t3f
+---@param r t3f
+---@return boolean
+function t3f.approximately(l, r) end
+
+---@param t t3f
+---@return boolean
+function t3f.contains_nan(t) end
+
+---@type t3f
+_G.t3f = _G.t3f or t3f

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

@@ -0,0 +1,113 @@
+---@class v2f
+local v2f = {
+    ---@type number
+    x = 0,
+
+    ---@type number
+    y = 0
+}
+
+---@overload fun(): v2f
+---@overload fun(v: number): v2f
+---@overload fun(x: number, y: number): v2f
+---@overload fun(v: v2f): v2f
+---@overload fun(v: v3f): v2f
+---@overload fun(v: v4f): v2f
+---@return v2f
+function v2f.new() end
+
+---@return v2f
+function v2f.zero() end
+
+---@return v2f
+function v2f.unit() end
+
+---@return v2f
+function v2f.unit_x() end
+
+---@return v2f
+function v2f.unit_y() end
+
+---@param l v2f
+---@param r v2f
+---@return boolean
+function v2f.approximately(l, r) end
+
+---@param l v2f
+---@param r v2f
+---@return number
+function v2f.dot(l, r) end
+
+---@param l v2f
+---@param r v2f
+---@return number
+function v2f.abs_dot(l, r) end
+
+---@param v v2f
+---@return number
+function v2f.length_squared(v) end
+
+---@param v v2f
+---@return number
+function v2f.length(v) end
+
+---@param l v2f
+---@param r v2f
+---@return number
+function v2f.distance_squared(l, r) end
+
+---@param l v2f
+---@param r v2f
+---@return number
+function v2f.distance(l, r) end
+
+---@param v v2f
+---@return v2f
+function v2f.normalized(v) end
+
+---@param v v2f
+---@return number
+function v2f.minimum(v) end
+
+---@param v v2f
+---@return number
+function v2f.maximum(v) end
+
+---@param v v2f
+---@param vmin v2f
+---@return v2f
+function v2f.minimized(v,vmin) end
+
+---@param v v2f
+---@param vmax v2f
+---@return v2f
+function v2f.maximized(v,vmax) end
+
+---@param v v2f
+---@param vmin v2f
+---@param vmax v2f
+---@return v2f
+function v2f.clamped(v,vmin,vmax) end
+
+---@param v v2f
+---@return v2f
+function v2f.saturated(v) end
+
+---@param l v2f
+---@param r v2f
+---@param v number | v2f
+---@return v2f
+function v2f.lerp(l,r,v) end
+
+---@param l v2f
+---@param r v2f
+---@param v v2f
+---@return v2f
+function v2f.inverse_lerp(l,r,v) end
+
+---@param v v2f
+---@return boolean
+function v2f.contains_nan(v) end
+
+---@type v2f
+_G.v2f = _G.v2f or v2f

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

@@ -0,0 +1,124 @@
+---@class v3f
+local v3f = {
+    ---@type number
+    x = 0,
+
+    ---@type number
+    y = 0,
+
+    ---@type number
+    z = 0
+}
+
+---@overload fun(): v3f
+---@overload fun(v: number): v3f
+---@overload fun(x: number, y: number, z: number): v3f
+---@overload fun(v: v2f, z: number): v3f
+---@overload fun(v: v3f): v3f
+---@overload fun(v: v4f): v3f
+---@return v3f
+function v3f.new() end
+
+---@return v3f
+function v3f.zero() end
+
+---@return v3f
+function v3f.unit() end
+
+---@return v3f
+function v3f.unit_x() end
+
+---@return v3f
+function v3f.unit_y() end
+
+---@return v3f
+function v3f.unit_z() end
+
+---@param l v3f
+---@param r v3f
+---@return boolean
+function v3f.approximately(l, r) end
+
+---@param l v3f
+---@param r v3f
+---@return number
+function v3f.dot(l, r) end
+
+---@param l v3f
+---@param r v3f
+---@return number
+function v3f.abs_dot(l, r) end
+
+---@param l v3f
+---@param r v3f
+---@return v3f
+function v3f.cross(l, r) end
+
+---@param v v3f
+---@return number
+function v3f.length_squared(v) end
+
+---@param v v3f
+---@return number
+function v3f.length(v) end
+
+---@param l v3f
+---@param r v3f
+---@return number
+function v3f.distance_squared(l, r) end
+
+---@param l v3f
+---@param r v3f
+---@return number
+function v3f.distance(l, r) end
+
+---@param v v3f
+---@return v3f
+function v3f.normalized(v) end
+
+---@param v v3f
+---@return number
+function v3f.minimum(v) end
+
+---@param v v3f
+---@return number
+function v3f.maximum(v) end
+
+---@param v v3f
+---@param vmin v3f
+---@return v3f
+function v3f.minimized(v,vmin) end
+
+---@param v v3f
+---@param vmax v3f
+---@return v3f
+function v3f.maximized(v,vmax) end
+
+---@param v v3f
+---@param vmin v3f
+---@param vmax v3f
+---@return v3f
+function v3f.clamped(v,vmin,vmax) end
+
+---@param v v3f
+---@return v3f
+function v3f.saturated(v) end
+
+---@param l v3f
+---@param r v3f
+---@param v number | v3f
+---@return v3f
+function v3f.lerp(l,r,v) end
+
+---@param l v3f
+---@param r v3f
+---@param v v3f
+---@return v3f
+function v3f.inverse_lerp(l,r,v) end
+
+---@param v v3f
+---@return boolean
+function v3f.contains_nan(v) end
+
+---@type v3f
+_G.v3f = _G.v3f or v3f

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

@@ -0,0 +1,125 @@
+---@class v4f
+local v4f = {
+    ---@type number
+    x = 0,
+
+    ---@type number
+    y = 0,
+
+    ---@type number
+    z = 0,
+
+    ---@type number
+    w = 0
+}
+
+---@overload fun(): v4f
+---@overload fun(v: number): v4f
+---@overload fun(x: number, y: number, z: number, w: number): v4f
+---@overload fun(v: v2f, z: number, w: number): v4f
+---@overload fun(v: v3f, w: number): v4f
+---@overload fun(v: v4f): v4f
+---@return v4f
+function v4f.new() end
+
+---@return v4f
+function v4f.zero() end
+
+---@return v4f
+function v4f.unit() end
+
+---@return v4f
+function v4f.unit_x() end
+
+---@return v4f
+function v4f.unit_y() end
+
+---@return v4f
+function v4f.unit_z() end
+
+---@return v4f
+function v4f.unit_w() end
+
+---@param l v4f
+---@param r v4f
+---@return boolean
+function v4f.approximately(l, r) end
+
+---@param l v4f
+---@param r v4f
+---@return number
+function v4f.dot(l, r) end
+
+---@param l v4f
+---@param r v4f
+---@return number
+function v4f.abs_dot(l, r) end
+
+---@param v v4f
+---@return number
+function v4f.length_squared(v) end
+
+---@param v v4f
+---@return number
+function v4f.length(v) end
+
+---@param l v4f
+---@param r v4f
+---@return number
+function v4f.distance_squared(l, r) end
+
+---@param l v4f
+---@param r v4f
+---@return number
+function v4f.distance(l, r) end
+
+---@param v v4f
+---@return v4f
+function v4f.normalized(v) end
+
+---@param v v4f
+---@return number
+function v4f.minimum(v) end
+
+---@param v v4f
+---@return number
+function v4f.maximum(v) end
+
+---@param v v4f
+---@param vmin v4f
+---@return v4f
+function v4f.minimized(v,vmin) end
+
+---@param v v4f
+---@param vmax v4f
+---@return v4f
+function v4f.maximized(v,vmax) end
+
+---@param v v4f
+---@param vmin v4f
+---@param vmax v4f
+---@return v4f
+function v4f.clamped(v,vmin,vmax) end
+
+---@param v v4f
+---@return v4f
+function v4f.saturated(v) end
+
+---@param l v4f
+---@param r v4f
+---@param v number | v4f
+---@return v4f
+function v4f.lerp(l,r,v) end
+
+---@param l v4f
+---@param r v4f
+---@param v v4f
+---@return v4f
+function v4f.inverse_lerp(l,r,v) end
+
+---@param v v4f
+---@return boolean
+function v4f.contains_nan(v) end
+
+---@type v4f
+_G.v4f = _G.v4f or v4f

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

@@ -51,7 +51,7 @@ namespace
                 sol::resolve<aabb<T>(const aabb<T>&, T)>(::operator/),
                 sol::resolve<aabb<T>(const aabb<T>&, const vec3<T>&)>(::operator/)),
 
-            "make_minmax_rect", sol::overload(
+            "make_minmax", sol::overload(
                 sol::resolve<aabb<T>(T,T,T,T,T,T)>(&math::make_minmax_aabb),
                 sol::resolve<aabb<T>(const vec3<T>&,const vec3<T>&)>(&math::make_minmax_aabb),
                 sol::resolve<aabb<T>(const aabb<T>&)>(&math::make_minmax_aabb)),

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

@@ -40,13 +40,13 @@ namespace
                 sol::resolve<mat2<T>(const mat2<T>&, T)>(::operator*),
                 sol::resolve<mat2<T>(const mat2<T>&, const mat2<T>&)>(::operator*)),
 
-            "make_scale_matrix2", sol::overload(
+            "make_scale", sol::overload(
                 sol::resolve<mat2<T>(T,T)>(&math::make_scale_matrix2),
                 sol::resolve<mat2<T>(const vec4<T>&)>(&math::make_scale_matrix2),
                 sol::resolve<mat2<T>(const vec3<T>&)>(&math::make_scale_matrix2),
                 sol::resolve<mat2<T>(const vec2<T>&)>(&math::make_scale_matrix2)),
 
-            "make_rotation_matrix2", sol::overload(
+            "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)),
 

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

@@ -40,13 +40,13 @@ namespace
                 sol::resolve<mat3<T>(const mat3<T>&, T)>(::operator*),
                 sol::resolve<mat3<T>(const mat3<T>&, const mat3<T>&)>(::operator*)),
 
-            "make_scale_matrix3", sol::overload(
+            "make_scale", sol::overload(
                 sol::resolve<mat3<T>(T,T,T)>(&math::make_scale_matrix3),
                 sol::resolve<mat3<T>(const vec4<T>&)>(&math::make_scale_matrix3),
                 sol::resolve<mat3<T>(const vec3<T>&)>(&math::make_scale_matrix3),
                 sol::resolve<mat3<T>(const vec2<T>&, T)>(&math::make_scale_matrix3)),
 
-            "make_rotation_matrix3", sol::overload(
+            "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),

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

@@ -40,19 +40,19 @@ namespace
                 sol::resolve<mat4<T>(const mat4<T>&, T)>(::operator*),
                 sol::resolve<mat4<T>(const mat4<T>&, const mat4<T>&)>(::operator*)),
 
-            "make_scale_matrix4", sol::overload(
+            "make_scale", sol::overload(
                 sol::resolve<mat4<T>(T,T,T)>(&math::make_scale_matrix4),
                 sol::resolve<mat4<T>(const vec4<T>&)>(&math::make_scale_matrix4),
                 sol::resolve<mat4<T>(const vec3<T>&)>(&math::make_scale_matrix4),
                 sol::resolve<mat4<T>(const vec2<T>&, T)>(&math::make_scale_matrix4)),
 
-            "make_translation_matrix4", sol::overload(
+            "make_translation", sol::overload(
                 sol::resolve<mat4<T>(T,T,T)>(&math::make_translation_matrix4),
                 sol::resolve<mat4<T>(const vec4<T>&)>(&math::make_translation_matrix4),
                 sol::resolve<mat4<T>(const vec3<T>&)>(&math::make_translation_matrix4),
                 sol::resolve<mat4<T>(const vec2<T>&, T)>(&math::make_translation_matrix4)),
 
-            "make_rotation_matrix4", sol::overload(
+            "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),
@@ -63,6 +63,32 @@ namespace
                 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)),
 
+            "make_trs", sol::overload(
+                sol::resolve<mat4<T>(const trs2<T>&)>(&math::make_trs_matrix4),
+                sol::resolve<mat4<T>(const trs3<T>&)>(&math::make_trs_matrix4)),
+
+            "make_look_at_lh", sol::resolve<
+                mat4<T>(const vec3<T>&,const vec3<T>&,const vec3<T>&)>(&math::make_look_at_lh_matrix4),
+
+            "make_look_at_rh", sol::resolve<
+                mat4<T>(const vec3<T>&,const vec3<T>&,const vec3<T>&)>(&math::make_look_at_rh_matrix4),
+
+            "make_orthogonal_lh", sol::overload(
+                sol::resolve<mat4<T>(T,T,T,T)>(&math::make_orthogonal_lh_matrix4),
+                sol::resolve<mat4<T>(const vec2<T>&,T,T)>(&math::make_orthogonal_lh_matrix4)),
+
+            "make_orthogonal_rh", sol::overload(
+                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_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)),
+
             "approximately", [](const mat4<T>& l, const mat4<T>& r){ return math::approximately(l,r); },
 
             "inversed", [](const mat4<T>& m){ return math::inversed(m); },

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

@@ -19,6 +19,9 @@ namespace
                 quat<T>(T,T,T,T),
                 quat<T>(vec4<T>)>(),
 
+            "zero", &quat<T>::zero,
+            "identity", &quat<T>::identity,
+
             "x", &quat<T>::x,
             "y", &quat<T>::y,
             "z", &quat<T>::z,
@@ -42,11 +45,11 @@ namespace
                 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(
+            "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_quat_from_euler_angles", sol::overload(
+            "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)),
 

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

@@ -51,7 +51,7 @@ namespace
                 sol::resolve<rect<T>(const rect<T>&, T)>(::operator/),
                 sol::resolve<rect<T>(const rect<T>&, const vec2<T>&)>(::operator/)),
 
-            "make_minmax_rect", sol::overload(
+            "make_minmax", sol::overload(
                 sol::resolve<rect<T>(T,T,T,T)>(&math::make_minmax_rect),
                 sol::resolve<rect<T>(const vec2<T>&,const vec2<T>&)>(&math::make_minmax_rect),
                 sol::resolve<rect<T>(const rect<T>&)>(&math::make_minmax_rect)),

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

@@ -20,7 +20,7 @@ namespace
                 trs2<T>(vec2<T>,rad<T>,vec2<T>)>(),
 
             "zero", &trs2<T>::zero,
-            "unit", &trs2<T>::identity,
+            "identity", &trs2<T>::identity,
 
             "translation", &trs2<T>::translation,
             "rotation", &trs2<T>::rotation,
@@ -32,11 +32,11 @@ namespace
 
             sol::meta_function::equal_to, sol::resolve<bool(const trs2<T>&, const trs2<T>&)>(::operator==),
 
-            "make_translation_trs2", sol::resolve<trs2<T>(const vec2<T>&)>(&math::make_translation_trs2),
-            "make_rotation_trs2", sol::overload(
+            "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_trs2", sol::resolve<trs2<T>(const vec2<T>&)>(&math::make_scale_trs2),
+            "make_scale", sol::resolve<trs2<T>(const vec2<T>&)>(&math::make_scale_trs2),
 
             "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));

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

@@ -19,7 +19,7 @@ namespace
                 trs3<T>(vec3<T>,quat<T>,vec3<T>)>(),
 
             "zero", &trs3<T>::zero,
-            "unit", &trs3<T>::identity,
+            "identity", &trs3<T>::identity,
 
             "translation", &trs3<T>::translation,
             "rotation", &trs3<T>::rotation,
@@ -31,9 +31,9 @@ namespace
 
             sol::meta_function::equal_to, sol::resolve<bool(const trs3<T>&, const trs3<T>&)>(::operator==),
 
-            "make_translation_trs3", sol::resolve<trs3<T>(const vec3<T>&)>(&math::make_translation_trs3),
-            "make_rotation_trs3", sol::resolve<trs3<T>(const quat<T>&)>(&math::make_rotation_trs3),
-            "make_scale_trs3", sol::resolve<trs3<T>(const vec3<T>&)>(&math::make_scale_trs3),
+            "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),
 
             "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));

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

@@ -18,6 +18,8 @@ namespace
                 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){

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

@@ -81,8 +81,9 @@ namespace
             "clamped", sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&, const vec2<T>&)>(&math::clamped),
             "saturated", sol::resolve<vec2<T>(const vec2<T>&)>(&math::saturated),
 
-            "lerp", sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&, T)>(&math::lerp),
-            "lerp", sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&, const vec2<T>&)>(&math::lerp),
+            "lerp", sol::overload(
+                sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&, T)>(&math::lerp),
+                sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&, const vec2<T>&)>(&math::lerp)),
             "inverse_lerp", sol::resolve<vec2<T>(const vec2<T>&, const vec2<T>&, const vec2<T>&)>(&math::inverse_lerp),
 
             "contains_nan", sol::resolve<bool(const vec2<T>&)>(&math::contains_nan));

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

@@ -9,7 +9,7 @@
 namespace
 {
     using namespace e2d;
-    
+
     template < typename T >
     void bind_vec3_t(const str& name, sol::state& l) {
         l.new_usertype<vec3<T>>(name,
@@ -86,8 +86,9 @@ namespace
             "clamped", sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&, const vec3<T>&)>(&math::clamped),
             "saturated", sol::resolve<vec3<T>(const vec3<T>&)>(&math::saturated),
 
-            "lerp", sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&, T)>(&math::lerp),
-            "lerp", sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&, const vec3<T>&)>(&math::lerp),
+            "lerp", sol::overload(
+                sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&, T)>(&math::lerp),
+                sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&, const vec3<T>&)>(&math::lerp)),
             "inverse_lerp", sol::resolve<vec3<T>(const vec3<T>&, const vec3<T>&, const vec3<T>&)>(&math::inverse_lerp),
 
             "contains_nan", sol::resolve<bool(const vec3<T>&)>(&math::contains_nan));

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

@@ -9,7 +9,7 @@
 namespace
 {
     using namespace e2d;
-    
+
     template < typename T >
     void bind_vec4_t(const str& name, sol::state& l) {
         l.new_usertype<vec4<T>>(name,
@@ -85,8 +85,9 @@ namespace
             "clamped", sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&, const vec4<T>&)>(&math::clamped),
             "saturated", sol::resolve<vec4<T>(const vec4<T>&)>(&math::saturated),
 
-            "lerp", sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&, T)>(&math::lerp),
-            "lerp", sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&, const vec4<T>&)>(&math::lerp),
+            "lerp", sol::overload(
+                sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&, T)>(&math::lerp),
+                sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&, const vec4<T>&)>(&math::lerp)),
             "inverse_lerp", sol::resolve<vec4<T>(const vec4<T>&, const vec4<T>&, const vec4<T>&)>(&math::inverse_lerp),
 
             "contains_nan", sol::resolve<bool(const vec4<T>&)>(&math::contains_nan));