math lua api is almost complete

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