examples/lua-scripting/scripts/test.lua

@@ -1,3 +1,5 @@
+--local win = require "scripts.window"
+
 local is_window_setup = false
 
 ---Return the userdata's name from its metatable.
@@ -17,7 +19,7 @@ end
  
 
 function on_init()
-    local cube = world:request_asset("../assets/cube-texture-embedded.gltf") --[[@as GltfHandle]]
+    local cube = world:request_res("../assets/cube-texture-embedded.gltf")
     print("Loaded textured cube (" .. udname(cube) .. ")")
 
     cube:wait_until_loaded()
@@ -43,8 +45,7 @@ function on_first()
                 is_window_setup = true
                 print("Window setup")
             end
-            end, Window
+        end, Window)
-        )
     end
 end
 
@@ -69,13 +70,10 @@ function on_update()
     ---@type number
     local dt = world:resource(DeltaTime)
 
-    world:view(
+    world:view(function (t)
-        ---@param t Transform
-        function (t)
         t:translate(0, 0.15 * dt, 0)
         return t
-        end, Transform
+    end, Transform)
-    )
 end
 
 --[[ function on_post_update()

lyra-game/src/input/action.rs

@@ -358,61 +358,66 @@ impl ActionHandler {
 
     /// Returns true if the action is pressed (or was just pressed).
     /// 
-    /// Returns `None` if the action was not found.
+    /// This will panic if the action name does not correspond to an action.
-    pub fn is_action_pressed<L>(&self, action: L) -> Option<bool>
+    pub fn is_action_pressed<L>(&self, action: L) -> bool
     where
         L: ActionLabel
     {
-        let action = self.actions.get(&action.label_hash())?;
+        let action = self.actions.get(&action.label_hash())
+            .unwrap_or_else(|| panic!("Action {action:?} was not found"));
 
-        Some(matches!(action.state, ActionState::Pressed(_) | ActionState::JustPressed(_)))
+        matches!(action.state, ActionState::Pressed(_) | ActionState::JustPressed(_))
     }
 
     /// Returns true if the action was just pressed.
     /// 
-    /// Returns `None` if the action was not found.
+    /// This will panic if the action name does not correspond to an action.
-    pub fn was_action_just_pressed<L>(&self, action: L) -> Option<bool>
+    pub fn was_action_just_pressed<L>(&self, action: L) -> bool
     where
         L: ActionLabel
     {
-        let action = self.actions.get(&action.label_hash())?;
+        let action = self.actions.get(&action.label_hash())
+            .unwrap_or_else(|| panic!("Action {action:?} was not found"));
 
-        Some(matches!(action.state, ActionState::JustPressed(_)))
+        matches!(action.state, ActionState::JustPressed(_))
     }
 
     /// Returns true if the action was just released.
     /// 
-    /// Returns `None` if the action was not found.
+    /// This will panic if the action name does not correspond to an action.
-    pub fn was_action_just_released<L>(&self, action: L) -> Option<bool>
+    pub fn was_action_just_released<L>(&self, action: L) -> bool
     where
         L: ActionLabel
     {
-        let action = self.actions.get(&action.label_hash())?;
+        let action = self.actions.get(&action.label_hash())
+            .unwrap_or_else(|| panic!("Action {action:?} was not found"));
 
-        Some(matches!(action.state, ActionState::JustReleased))
+        matches!(action.state, ActionState::JustReleased)
     }
 
     /// Returns an action's state.
     /// 
-    /// Returns `None` if the action was not found.
+    /// This will panic if the action name does not correspond to an action.
-    pub fn get_action_state<L>(&self, action: L) -> Option<ActionState>
+    pub fn get_action_state<L>(&self, action: L) -> ActionState
     where
         L: ActionLabel
     {
-        let action = self.actions.get(&action.label_hash())?;
+        let action = self.actions.get(&action.label_hash())
+            .unwrap_or_else(|| panic!("Action {action:?} was not found"));
 
-        Some(action.state)
+        action.state
     }
 
     /// Returns the action's modifier if it is pressed (or was just pressed).
+    /// Returns `None` if the action's state is not `ActionState::Pressed` or `ActionState::JustPressed`.
     /// 
-    /// Returns `None` if the action's state is not `ActionState::Pressed`, `ActionState::JustPressed`,
+    /// This will panic if the action name does not correspond to an action.
-    /// or if the action was not found.
     pub fn get_pressed_modifier<L>(&self, action: L) -> Option<f32>
     where
         L: ActionLabel
     {
-        let action = self.actions.get(&action.label_hash())?;
+        let action = self.actions.get(&action.label_hash())
+            .unwrap_or_else(|| panic!("Action {action:?} was not found"));
 
         match action.state {
             ActionState::Pressed(v) | ActionState::JustPressed(v) => Some(v),
@@ -421,14 +426,15 @@ impl ActionHandler {
     }
 
     /// Returns the action's modifier if it was just pressed.
+    /// Returns `None` if the action's state is not `ActionState::JustPressed`.
     /// 
-    /// Returns `None` if the action's state is not `ActionState::JustPressed`,
+    /// This will panic if the action name does not correspond to an action.
-    /// or if the action was not found.
     pub fn get_just_pressed_modifier<L>(&self, action: L) -> Option<f32>
     where
         L: ActionLabel
     {
-        let action = self.actions.get(&action.label_hash())?;
+        let action = self.actions.get(&action.label_hash())
+            .unwrap_or_else(|| panic!("Action {action:?} was not found"));
 
         match action.state {
             ActionState::JustPressed(v) => Some(v),
@@ -437,14 +443,15 @@ impl ActionHandler {
     }
     
     /// Returns the action's modifier if its an updated axis.
+    /// Returns `None` if the action's state is not `ActionState::Axis`.
     /// 
-    /// Returns `None` if the action's state is not `ActionState::Axis`,
+    /// This will panic if the action name does not correspond to an action.
-    /// or if the action was not found.
     pub fn get_axis_modifier<L>(&self, action: L) -> Option<f32>
     where
         L: ActionLabel
     {
-        let action = self.actions.get(&action.label_hash())?;
+        let action = self.actions.get(&action.label_hash())
+            .unwrap_or_else(|| panic!("Action {action:?} was not found"));
 
         match action.state {
             ActionState::Axis(v) => Some(v),

lyra-math/src/transform.rs

@@ -28,6 +28,10 @@ impl Default for Transform {
 
 // TODO: https://www.brainvoyager.com/bv/doc/UsersGuide/CoordsAndTransforms/SpatialTransformationMatrices.html
 
+#[allow(dead_code)]
+const ZERO_V3: Vec3 = Vec3::new(0.0, 0.0, 0.0);
+const ONE_V3: Vec3 = Vec3::new(1.0, 1.0, 1.0);
+
 #[allow(dead_code)]
 impl Transform {
     pub fn new(translation: Vec3, rotation: Quat, scale: Vec3) -> Self {
@@ -39,42 +43,33 @@ impl Transform {
     }
 
     pub fn from_translation(translation: Vec3) -> Self {
-        Self::new(translation, Quat::IDENTITY, Vec3::ONE)
+        Self::new(translation, Quat::IDENTITY, ONE_V3)
     }
 
     pub fn from_xyz(x: f32, y: f32, z: f32) -> Self {
-        Self::new(Vec3::new(x, y, z), Quat::IDENTITY, Vec3::ONE)
+        Self::new(Vec3::new(x, y, z), Quat::IDENTITY, ONE_V3)
     }
 
     pub fn calculate_mat4(&self) -> Mat4 {
         Mat4::from_scale_rotation_translation(self.scale, self.rotation, self.translation)
     }
 
-    /// Returns a normalized vector pointing in the direction the Transform is facing.
+    /// Get the forward vector of the Transform.
-    /// 
-    /// This represents the front of the object can be used for movement, camera orientation, and
-    /// other directional calculations.
     pub fn forward(&self) -> Vec3 {
         (self.rotation * -Vec3::Z).normalize()
     }
 
-    /// Returns a normalized vector pointing to the left side of the Transform.
+    /// Get the left vector of the Transform.
-    /// 
-    /// The vector is in local space. This represents the direction that is
-    /// perpendicular to the object's forward direction.
     pub fn left(&self) -> Vec3 {
         (self.rotation * Vec3::X).normalize()
     }
 
-    /// Returns a normalized vector that indicates the upward direction of the Transform.
+    /// Get the up vector of the Transform.
-    /// 
-    /// This vector is commonly used to define an object's orientation and is essential for maintaining
-    /// consistent vertical alignment in 3D environments, such as for camera positioning and object alignment.
     pub fn up(&self) -> Vec3 {
         (self.rotation * Vec3::Y).normalize()
     }
 
-    /// Rotate this transform using a Quaternion.
+    /// Rotate this transform using a Quaternion
     pub fn rotate(&mut self, rotation: Quat) {
         self.rotation = (rotation * self.rotation).normalize();
     }
@@ -115,7 +110,7 @@ impl Transform {
             let mut res = *self;
             res.translation = self.translation.lerp(rhs.translation, alpha);
             // normalize rotation here to avoid panics
-            res.rotation = self.rotation.normalize().lerp(rhs.rotation.normalize(), alpha);
+            res.rotation = self.rotation.lerp(rhs.rotation.normalize(), alpha);
             res.scale = self.scale.lerp(rhs.scale, alpha);
             res
         } else {

lyra-scripting/scripts/lua/action_handler.lua

@@ -1,9 +0,0 @@
----@enum ActionState
-ActionState = {
-    IDLE = "idle",
-    PRESSED = "pressed",
-    JUST_PRESSED = "just_pressed",
-    JUST_RELEASED = "just_released",
-    AXIS = "axis",
-    OTHER = "other",
-}

lyra-scripting/scripts/lua/asset_handle.lua

@@ -1,12 +0,0 @@
----@enum HandleState
-HandleState = {
-    LOADING = "loading",
-    READY = "ready",
-    ERROR = "error",
-}
-
----@enum ActionKind
-ActionKind = {
-    BUTTON = "button",
-    AXIS = "axis",
-}

lyra-scripting/scripts/lua/math/quat.lua

@@ -0,0 +1,182 @@
+---@class Quat
+---@field x number
+---@field y number
+---@field z number
+---@field w number
+Quat = { x = 0.0, y = 0.0, z = 0.0, w = 0.0 }
+Quat.__index = Quat
+Quat.__name = "Quat"
+
+--- Constructs a new Quaternion from x, y, z, and w.
+---@param x number
+---@param y number
+---@param z number
+---@param w number
+---@return Quat
+function Quat:new(x, y, z, w)
+    local q = {}
+    setmetatable(q, Quat)
+    
+    q.x = x
+    q.y = y
+    q.z = z
+    q.w = w
+    
+    return q
+end
+
+Quat.IDENTITY = Quat:new(0, 0, 0, 1)
+
+function Quat:clone()
+    return Quat:new(self.x, self.y, self.z, self.w)
+end
+
+--- Creates a quaternion from the angle, in radians, around the x axis.
+--- @param rad number
+--- @return Quat
+function Quat:from_rotation_x(rad)
+    local sin = math.sin(rad * 0.5)
+    local cos = math.cos(rad * 0.5)
+    return Quat:new(sin, 0, 0, cos)
+end
+
+--- Creates a quaternion from the angle, in radians, around the y axis.
+--- @param rad number
+--- @return Quat
+function Quat:from_rotation_y(rad)
+    local sin = math.sin(rad * 0.5)
+    local cos = math.cos(rad * 0.5)
+    return Quat:new(0, sin, 0, cos)
+end
+
+--- Creates a quaternion from the angle, in radians, around the z axis.
+--- @param rad number
+--- @return Quat
+function Quat:from_rotation_z(rad)
+    local sin = math.sin(rad * 0.5)
+    local cos = math.cos(rad * 0.5)
+    return Quat:new(0, 0, sin, cos)
+end
+
+--- Computes the dot product of `self`.
+---@param rhs Quat
+---@return number
+function Quat:dot(rhs)
+    return (self.x * rhs.x) + (self.y * rhs.y) + (self.z * rhs.z) + (self.w * rhs.w)
+end
+
+--- Computes the length of `self`.
+---@return number
+function Quat:length()
+    return math.sqrt(self:dot(self))
+end
+
+--- Compute the length of `self` squared.
+---@return number
+function Quat:length_squared()
+    return self:length() ^ 2
+end
+
+--- Normalizes `self` and returns the new Quat
+---@return unknown
+function Quat:normalize()
+    local length = self:length()
+    return self / length
+end
+
+--- Multiplies two Quaternions together. Keep in mind that Quaternion multiplication is NOT
+--- commutative so the order in which you multiply the quaternions matters.
+---@param rhs Quat
+---@return Quat
+function Quat:mult_quat(rhs)
+    local x1, y1, z1, w1 = self.x, self.y, self.z, self.w
+    local x2, y2, z2, w2 = rhs.x, rhs.y, rhs.z, rhs.w
+
+    local x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2
+    local y = w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2
+    local z = w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2
+    local w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * x2
+    
+    return Quat:new(x, y, z, w)
+end
+
+--- Multiplies `self` by a Vec3, returning the rotated Vec3
+---@param vec Vec3
+---@return Vec3
+function Quat:mult_vec3(vec)
+    local vec_quat = Quat:new(vec.x, vec.y, vec.z, 0)
+    local quat = self:mult_quat(vec_quat)
+    return Vec3:new(quat.x, quat.y, quat.z)
+end
+
+--- Calculates the linear iterpolation between `self` and `rhs` based on the `alpha`.
+--- When `alpha` is `0`, the result will be equal to `self`. When `s` is `1`, the result
+--- will be equal to `rhs`
+--- @param rhs Quat
+--- @param alpha number
+--- @return Quat
+function Quat:lerp(rhs, alpha)
+    -- ensure alpha is [0, 1]
+    local alpha = math.max(0, math.min(1, alpha))
+
+    local x1, y1, z1, w1 = self.x, self.y, self.z, self.w
+    local x2, y2, z2, w2 = rhs.x, rhs.y, rhs.z, rhs.w
+
+    local x = (1 - alpha) * x1 + alpha * x2
+    local y = (1 - alpha) * y1 + alpha * y2
+    local z = (1 - alpha) * z1 + alpha * z2
+    local w = (1 - alpha) * w1 + alpha * w2
+
+    return Quat:new(x, y, z, w):normalize()
+end
+
+function Quat:__add(rhs)
+    return Quat:new(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z, self.w + rhs.w)
+end
+
+function Quat:__sub(rhs)
+    return Quat:new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z, self.w - rhs.w)
+end
+
+function Quat:__mul(rhs)
+    if type(rhs) == "number" then
+        return Quat:new(self.x * rhs, self.y * rhs, self.z * rhs, self.w * rhs)
+    elseif type(rhs) == "table" then
+        local name = rhs.__name
+
+        if name == "Vec3" then
+            return self:mult_vec3(rhs)
+        elseif name == "Quat" then
+            return self:mult_quat(rhs)
+        else
+            assert(false, "Unknown usertype of rhs" .. name)
+        end
+    else
+        assert(false, "Unknown type of rhs" .. type(rhs))
+    end
+end
+
+function Quat:__div(rhs)
+    if type(rhs) == "number" then
+        return Quat:new(self.x / rhs, self.y / rhs, self.z / rhs, self.w / rhs)
+    else
+        assert(rhs.__name == "Quat", "Attempted to divide Quat by unknown type " .. rhs.__name)
+        return Quat:new(self.x / rhs.x, self.y / rhs.y, self.z / rhs.z, self.w / rhs.w)
+    end
+end
+
+function Quat:__eq(rhs)
+    return self.x == rhs.x and self.y == rhs.y and self.z == rhs.z and self.w == rhs.w
+end
+
+function Quat:__lt(rhs)
+    return self.x < rhs.x and self.y < rhs.y and self.z < rhs.z and self.w < rhs.w
+end
+
+function Quat:__le(rhs)
+    return self.x <= rhs.x and self.y <= rhs.y and self.z <= rhs.z and self.w <= rhs.w
+end
+
+function Quat:__tostring()
+    return "Quat(" .. self.x .. ", " .. self.y .. ", " .. self.z .. ", " .. self.w .. ")"
+end

lyra-scripting/scripts/lua/math/transform.lua

@@ -0,0 +1,95 @@
+---@class Transform
+---@field translation Vec3
+---@field rotation Quat
+---@field Scale Vec3
+Transform = { translation = Vec3.ZERO, rotation = Quat.IDENTITY, scale = Vec3.ONE }
+Transform.__index = Transform
+Transform.__name = "Transform"
+
+function Transform:new(translation, rotation, scale)
+    local t = {}
+    setmetatable(t, Transform)
+    
+    t.translation = translation
+    t.rotation = rotation
+    t.scale = scale
+    
+    return t
+end
+
+function Transform:clone()
+    return Transform:new(self.translation:clone(), self.rotation:clone(), self.scale:clone())
+end
+
+--- Creates a new Transform with the translation at the vec3
+--- @param pos Vec3
+function Transform:from_vec3(pos)
+    local t = Transform:clone() -- copy of default transform
+    t.translation = pos
+    return t
+end
+
+function Transform:from_xyz(x, y, z)
+    Transform:from_vec3(Vec3:new(x, y, z))
+end
+
+--- Calculates the forward vector of the Transform.
+--- @return Vec3
+function Transform:forward()
+    return (self.rotation * Vec3.NEG_Z):normalize()
+end
+
+--- Calculates the left vector of the Transform.
+--- @return Vec3
+function Transform:left()
+    return (self.rotation * Vec3.X):normalize()
+end
+
+--- Calculates the up vector of the Transform.
+--- @return Vec3
+function Transform:up()
+    return (self.rotation * Vec3.Y):normalize()
+end
+
+--- Rotates `self` using a Quaternion
+--- @param quat Quat
+function Transform:rotate(quat)
+    self.rotation = (quat * self.rotation):normalize()
+end
+
+--- Rotates `self` around the x-axis
+--- @param rad number
+function Transform:rotate_x(rad)
+    self:rotate(Quat:from_rotation_x(rad))
+end
+
+--- Rotates `self` around the y-axis
+--- @param rad number
+function Transform:rotate_y(rad)
+    self:rotate(Quat:from_rotation_y(rad))
+end
+
+--- Rotates `self` around the z-axis
+--- @param rad number
+function Transform:rotate_z(rad)
+    self:rotate(Quat:from_rotation_z(rad))
+end
+
+--- Calculates the linear iterpolation between `self` and `rhs` based on the `alpha`.
+--- When `alpha` is `0`, the result will be equal to `self`. When `s` is `1`, the result
+--- will be equal to `rhs`
+--- @param rhs Transform
+--- @param alpha number
+--- @return Transform
+function Transform:lerp(rhs, alpha)
+    local res = self:clone()
+    res.translation = self.translation:lerp(rhs.translation, alpha)
+    res.rotation = self.rotation:lerp(rhs.rotation, alpha)
+    res.scale = self.scale:lerp(rhs.scale, alpha)
+    return res
+end
+
+function Transform:__tostring()
+    return "Transform(pos=" .. tostring(self.translation) .. ", rot="
+        .. tostring(self.rotation) .. ", scale=" .. tostring(self.scale) .. ")"
+end

lyra-scripting/scripts/lua/math/vec3.lua

@@ -0,0 +1,187 @@
+---@class Vec3
+---@field x number
+---@field y number
+---@field z number
+Vec3 = { x = 0.0, y = 0.0, z = 0.0 }
+Vec3.__index = Vec3
+Vec3.__name = "Vec3"
+
+--- Constructs a new vector
+---@param x number
+---@param y number
+---@param z number
+---@return Vec3
+function Vec3:new(x, y, z)
+    local v = {}
+    setmetatable(v, Vec3)
+    
+    v.x = x
+    v.y = y
+    v.z = z
+
+    return v
+end
+
+---Creates a copy of self
+---@return Vec3
+function Vec3:clone()
+    return Vec3:new(self.x, self.y, self.z)
+end
+
+--- Constructs a vector with all elements as parameter `x`.
+---@param x number
+---@return Vec3
+function Vec3:all(x)
+    return Vec3:new(x, x, x)
+end
+
+--- A unit-length vector pointing alongside the positive X axis.
+Vec3.X = Vec3:new(1, 0, 0)
+--- A unit-length vector pointing alongside the positive Y axis.
+Vec3.Y = Vec3:new(0, 1, 0)
+--- A unit-length vector pointing alongside the positive Z axis.
+Vec3.Z = Vec3:new(0, 0, 1)
+
+--- A unit-length vector pointing alongside the negative X axis.
+Vec3.NEG_X = Vec3:new(-1, 0, 0)
+--- A unit-length vector pointing alongside the negative Y axis.
+Vec3.NEG_Y = Vec3:new(0, -1, 0)
+--- A unit-length vector pointing alongside the negative Z axis.
+Vec3.NEG_Z = Vec3:new(0, 0, -1)
+
+--- A vector of all zeros
+Vec3.ZERO = Vec3:new(0, 0, 0)
+--- A vector of all ones
+Vec3.ONE = Vec3:new(1, 1, 1)
+
+--- Computes the absolute value of `self`.
+function Vec3:abs()
+    self.x = math.abs(self.x)
+    self.y = math.abs(self.y)
+    self.z = math.abs(self.z)
+end
+
+--- Computes the length of `self`.
+---@return number
+function Vec3:length()
+    return math.sqrt(self:dot(self))
+end
+
+---Moves `self` by the provided coordinates
+---@param x number
+---@param y number
+---@param z number
+function Vec3:move_by(x, y, z)
+    self.x = self.x + x
+    self.y = self.y + y
+    self.z = self.z + z
+end
+
+--- Computes the dot product of `self` and `rhs`.
+---@param rhs Vec3
+---@return number
+function Vec3:dot(rhs)
+    assert(rhs.__name == "Vec3")
+
+    return (self.x * rhs.x) + (self.y * rhs.y) + (self.z * rhs.z)
+end
+
+--- Returns a vector that has the minimum value of each element of `self` and `rhs`
+---@param rhs Vec3
+---@return Vec3
+function Vec3:min(rhs)
+    local x = math.min(self.x, rhs.x)
+    local y = math.min(self.y, rhs.y)
+    local z = math.min(self.z, rhs.z)
+
+    return Vec3:new(x, y, z)
+end
+
+--- Modifies `self` to be normalized to a length 1.
+function Vec3:normalize()
+    local len_recip = 1.0 / self:length()
+    self.x = self.x * len_recip
+    self.y = self.y * len_recip
+    self.z = self.z * len_recip
+end
+
+--- Calculates the linear iterpolation between `self` and `rhs` based on the `alpha`.
+--- When `alpha` is `0`, the result will be equal to `self`. When `s` is `1`, the result
+--- will be equal to `rhs`
+--- @param rhs Vec3
+--- @param alpha number
+--- @return Vec3
+function Vec3:lerp(rhs, alpha)
+    -- ensure alpha is [0, 1]
+    local alpha = math.max(0, math.min(1, alpha))
+
+    local res = self:clone()
+    res = res + ((rhs - res) * alpha)
+    return res
+end
+
+function Vec3:__add(rhs)
+    if type(rhs) == "Vec3" then
+        return Vec3:new(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)
+    else
+        return Vec3:new(self.x + rhs, self.y + rhs, self.z + rhs)
+    end
+end
+
+function Vec3:__sub(rhs)
+    if type(rhs) == "Vec3" then
+        return Vec3:new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
+    else
+        return Vec3:new(self.x - rhs, self.y - rhs, self.z - rhs)
+    end
+end
+
+function Vec3:__mul(rhs)
+    if type(rhs) == "Vec3" then
+        return Vec3:new(self.x * rhs.x, self.y * rhs.y, self.z * rhs.z)
+    else
+        return Vec3:new(self.x * rhs, self.y * rhs, self.z * rhs)
+    end
+end
+
+function Vec3:__div(rhs)
+    if type(rhs) == "Vec3" then
+        return Vec3:new(self.x / rhs.x, self.y / rhs.y, self.z / rhs.z)
+    else
+        return Vec3:new(self.x / rhs, self.y / rhs, self.z / rhs)
+    end
+end
+
+function Vec3:__idiv(rhs)
+    if type(rhs) == "Vec3" then
+        return Vec3:new(self.x // rhs.x, self.y // rhs.y, self.z // rhs.z)
+    else
+        return Vec3:new(self.x // rhs, self.y // rhs, self.z // rhs)
+    end
+end
+
+function Vec3:__unm()
+    return Vec3:new(-self.x, -self.y, -self.z)
+end
+
+function Vec3:__pow(rhs)
+    if type(rhs) == "number" then
+        return Vec3:new(self.x ^ rhs, self.y ^ rhs, self.z ^ rhs)
+    end
+end
+
+function Vec3:__eq(rhs)
+    return self.x == rhs.x and self.y == rhs.y and self.z == rhs.z
+end
+
+function Vec3:__lt(rhs)
+    return self.x < rhs.x and self.y < rhs.y and self.z < rhs.z
+end
+
+function Vec3:__le(rhs)
+    return self.x <= rhs.x and self.y <= rhs.y and self.z <= rhs.z
+end
+
+function Vec3:__tostring()
+    return "Vec3(" .. self.x .. ", " .. self.y .. ", " .. self.z .. ")"
+end

lyra-scripting/scripts/lua/types/asset/gltf_handle.lua

@@ -1,23 +0,0 @@
----@meta
-
----@class GltfHandle: Handle
----
----A handle to a GLTF asset.
-GltfHandle = {
-    
-}
-
----Get a list of scenes in the GLTF file.
----
----@return SceneHandle[]
-function GltfHandle:scenes() end
-
----Get a list of materials in the GLTF file.
----
----@return MaterialHandle[]
-function GltfHandle:materials() end
-
----Get a list of meshes in the GLTF file.
----
----@return MeshHandle[]
-function GltfHandle:meshes() end

lyra-scripting/scripts/lua/types/asset/handle.lua

@@ -1,43 +0,0 @@
----@meta
-
----@class Handle: userdata
----
----A handle to an asset. Assets are loaded asynchronously, so you cannot immediately
----use them after you request them from the World.
-Handle = {
-    ---The path the asset was loaded from.
-    ---
-    ---@type string
-    path = nil,
-    
-    ---The version of the resource.
-    ---
-    ---Increments every time a resource is loaded.
-    ---
-    ---@type number
-    version = nil,
-
-    ---The unique id of the resource.
-    ---
-    ---This is not changed for the entire lifetime of the handle, it does not change
-    ---when an asset is reloaded.
-    ---
-    ---@type string
-    uuid = nil,
-
-    ---Current state of the asset handle.
-    ---@type HandleState
-    state = nil,
-}
-
----Returns true if the asset is watched for auto-reloading.
----
----@return boolean
-function Handle:is_watched() end
-
----Returns true if the asset is loaded.
----@return boolean
-function Handle:is_loaded() end
-
----Blocks execution until the asset and its dependencies are loaded.
-function Handle:wait_until_loaded() end

lyra-scripting/scripts/lua/types/asset/material_handle.lua

@@ -1,102 +0,0 @@
----@meta
-
----@class MaterialHandle: Handle
----
----A handle to a material asset in a GLTF file.
-MaterialHandle = {
-    ---The unique id of the GPU shader.
-    ---@type number?
-    shader_uuid = nil,
-
-    ---The name of the material from GLTF.
-    ---@type string?
-    name = nil,
-
-    ---@type boolean
-    double_sided = nil,
-
-    ---The RGBA base color of the model.
-    ---
-    ---If a texture is supplied with `base_color_texture`, this value will tint the
-    ---texture. If a texture is not provided, this value would be the color of
-    ---the Material.
-    ---
-    ---@type Vec4
-    base_color = nil,
-
-    ---The metalness of the material
-    ---
-    ---From 0.0 (non-metal) to 1.0 (metal).
-    ---
-    ---@type number
-    metallic = nil,
-
-    ---The roughness of the material
-    ---
-    ---From 0.0 (smooth) to 1.0 (rough)
-    ---
-    ---@type number
-    roughness = nil,
-
-    ---The base color texture of the model.
-    ---@type TextureHandle?
-    base_color_texture = nil,
-    
-    ---The metallic-roughness texture.
-    ---
-    ---The metalness values are sampled from the B channel. The roughness values are sampled from
-    ---the G channel. These values are linear. If other channels are present (R or A), they are
-    ---ignored for metallic-roughness calculations.
-    ---@type TextureHandle?
-    metallic_roughness_texture = nil,
-    
-    ---A set of parameter values that are used to define the specular-glossiness material model
-    ---from Physically-Based Rendering (PBR) methodology.
-    ---GLTF extension: [KHR_materials_pbrSpecularGlossiness](https://kcoley.github.io/glTF/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness)
-    ---@type TextureHandle?
-    pbr_glossiness = nil,
-
-    ---The optional alpha cutoff value of the material.
-    ---
-    ---This will be used instead of the renderer's default.
-    ---
-    ---@type number?
-    alpha_cutoff = nil,
-
-    ---The alpha rendering mode of the material.
-    ---
-    ---The material's alpha rendering
-    ---mode enumeration specifying the interpretation of the alpha value of the main
-    ---factor and texture.
-    ---
-    ---* In `Opaque` mode (default) the alpha value is ignored
-    ---  and the rendered output is fully opaque.
-    ---* In `Mask` mode, the rendered
-    ---  output is either fully opaque or fully transparent depending on the alpha
-    ---  value and the specified alpha cutoff value.
-    ---* In `Blend` mode, the alpha value is used to composite the source and
-    ---  destination areas and the rendered output is combined with the background
-    ---  using the normal painting operation (i.e. the Porter and Duff over
-    ---  operator).
-    --- 
-    ---@type AlphaMode
-    alpha_mode = nil,
-    
-    ---@type Specular?
-    specular = nil,
-}
-
----@enum AlphaMode
-AlphaMode = {
-    OPAQUE = "opaque",
-    MASK = "mask",
-    BLEND = "blend",
-}
-
----@class PbrGlossiness
----TODO: implement
-PbrGlossiness = {}
-
----@class Specular
----TODO: implement
-Specular = {}

lyra-scripting/scripts/lua/types/asset/mesh_handle.lua

@@ -1,14 +0,0 @@
----@meta
-
----@class MeshHandle: Handle
----
----A handle to a mesh in a GLTF file.
-MeshHandle = {
-    ---The material of the mesh
-    ---@type MaterialHandle
-    material = nil,
-}
-
----Get the indices in the mesh.
----@return number[]
-function MeshHandle:indices() end

lyra-scripting/scripts/lua/types/asset/scene_handle.lua

@@ -1,9 +0,0 @@
----@meta
-
----@class SceneHandle: Handle
----
----A handle to a scene asset in a GLTF file.
-SceneHandle = {
-    
-}
-

lyra-scripting/scripts/lua/types/asset/texture_handle.lua

@@ -1,4 +0,0 @@
----@meta
-
----@class TextureHandle
-TextureHandle = {}

lyra-scripting/scripts/lua/types/ecs/action_handler.lua

@@ -1,125 +0,0 @@
----@meta
-
----@class ActionHandler: userdata
-ActionHandler = {}
-
---- Create a new `ActionHandler`.
----
---- ```lua
---- local handler = ActionHandler.new {
----     -- A list of layout IDs
----     layouts = { 0 },
----     actions = {
----         -- A list of action names and the `ActionKind`s.
----         -- Actions can be buttons or axes.
----         MoveForwardBackward = ActionKind.AXIS,
----         MoveLeftRight = ActionKind.AXIS,
----         MoveUpDown = ActionKind.AXIS,
----         LookLeftRight = ActionKind.AXIS,
----         LookUpDown = ActionKind.AXIS,
----         LookRoll = ActionKind.AXIS,
----         ObjectsMoveUpDown = ActionKind.AXIS
----     },
----     mappings = {
----         -- Each entry here is a mapping of actions for a layout.
----         -- This can be used so that when the current layout is changed,
----         -- the mapping would also change.
----         {
----             -- Specify the layout id that this mapping is for.
----             layout = 0,
----             binds = {
----                 -- This is an Action bind. A bind is used to bind an input to an action.
----                 -- These actions are defined above in "actions".
----                 MoveForwardBackward = {
----                     -- This is how you bind a button. In this case the button is a key.
----                     -- "key" is the device the bind comes from, then after the colon is the
----                     -- input name, in this case a specific key. We specify a modifier to the bind
----                     -- after the equal sign.
----                     "key:w=1.0",
----                     "key:s=-1.0"
----                 },
----                 MoveLeftRight = {
----                     "key:a=-1.0", "key:d=1.0"
----                 },
----                 MoveUpDown = {
----                     "key:c=1.0", "key:z=-1.0"
----                 },
----                 LookLeftRight = {
----                     "key:left=-1.0", "key:right=1.0",
----                     -- Here is a bind to an axis.
----                     -- We use "mouse", for the device the bind is from, then "axis" to specify
----                     -- that we want to bind a specific axis, then we use the name of the axis,
----                     -- in this case "x".
----                     -- So this binds to the x axis of the mouse.
----                     "mouse:axis:x"
----                 },
----                 LookUpDown = {
----                     "key:up=-1.0", "key:down=1.0",
----                     -- Here we bind to the y axis of the mouse.
----                     "mouse:axis:y",
----                 },
----                 LookRoll = {
----                     "key:e=-1.0", "key:q=1.0",
----                 },
----                 ObjectsMoveUpDown = {
----                     "key:u=1.0", "key:j=-1.0"
----                 }
----             }
----         }
----     }
---- }
---- 
---- -- Add the handler to the world so the host will process it.
---- world:add_resource(handler)
---- ```
----
----@param table table See above example to see the format of this table.
-function ActionHandler.new(table) end
-
----Returns the action's modifier if its an updated axis.
----
----Returns `nil` if the action's state is not `ActionState::Axis`, or if the
----action was not found.
----@param action string
----@return number?
-function ActionHandler:get_axis(action) end
-
----Returns true if the action is pressed (or was just pressed).
----
----Returns `nil` if the action's was not found.
----@param action string
----@return boolean?
-function ActionHandler:is_pressed(action) end
-
----Returns true if the action was **just** pressed.
----
----Returns `nil` if the action was not found
----
----@param action string
----@return boolean?
-function ActionHandler:was_just_pressed(action) end
-
----Returns true if the action was just released.
----
----Returns `nil` if the action was not found
----
----@param action string
----@return boolean?
-function ActionHandler:was_just_released(action) end
-
----Returns the action's modifier if it was just pressed.
----
----Returns `nil` if the action's state is not `ActionState.JUST_PRESSED`,
----or if the action was not found.
----
----@param action string
----@return number?
-function ActionHandler:get_just_pressed(action) end
-
----Returns the current state of the action.
----
----The first element in the returned tuple is the state enum, and the second
----is the state modifier. The modifer will be `nil` if the state is "idle"
----
----@return [ActionState, number?]
-function ActionHandler:get_action_state(action) end

lyra-scripting/scripts/lua/types/ecs/delta_time.lua

@@ -1,15 +0,0 @@
----@meta
-
----@class DeltaTime: userdata
----
----DeltaTime is an ECS world resource. When its requested from the world, a `number`
----is returned.
----
----Example:
----```lua
-------@type number
----local dt = world:resource(DeltaTime)
----
----print(type(dt)) --> number
----```
-DeltaTime = {}

lyra-scripting/scripts/lua/types/ecs/entity.lua

@@ -1,4 +0,0 @@
----@meta
-
----@class Entity: userdata
-Entity = {}

lyra-scripting/scripts/lua/types/ecs/window.lua

@@ -1,4 +1,4 @@
----@class Window: userdata
+---@class Window
 Window = {
     ---Gets or sets the window's focus.
     ---@type boolean

lyra-scripting/scripts/lua/types/ecs/world.lua

@@ -1,75 +0,0 @@
----@meta
-
----@class World: userdata
-World = {}
-
----Spawn an entity with components.
----
----@param ... userdata The components to spawn on the new entity, currently must be userdata.
----@return Entity
-function World:spawn(...) end
-
---- Query components from the world.
----
---- The `system` parameter is a function with the requested components. The function
---- is ran every time for an entity. If you modify a component and want the changes to be
---- stored, return it in the function. The order of the returned components do not matter.
----
---- Example:
---- ```lua
---- ---@type number
---- local dt = world:resource(DeltaTime)
---- 
---- world:view(
----     ---@param t Transform
----     function (t)
----         -- Move the transform of the entity a bit
----         t:translate(0, 0.15 * dt, 0)
----         -- Since the transform was modified, it must be returned so
----         -- the engine can store the changes.
----         return t
----     end,
----     -- Specify the requested components here
----     Transform
---- )
---- ```
----
----@param system fun(...): ...
----@param ... userdata
-function World:view(system, ...) end
-
----Get an ECS resource.
----
----Returns `nil` if the resource was not found in the world. Many resources will
----return userdata, however some may return Lua types like `DeltaTime`
----returning a `number`.
----
----Example:
----```lua
-------@type number
----local dt = world:resource(DeltaTime)
----
----print(type(dt)) --> number
----```
----
----@param resource userdata This shouldn't be an instance of userdata.
----@return any?
-function World:resource(resource) end
-
----Add a resource to the world.
----
----If the resource already exists, it will be overwritten.
----
----@param resource userdata
-function World:add_resource(resource) end
-
----Request an asset.
----
----Assets are loaded asyncronously, so you must wait before trying to access fields on
----the asset. You can spawn an entity with it when its still loading.
----
----Returns an asset handle to the requested resource type
----
----@param path string
----@return Handle asset An asset handle to the requested resource type.
-function World:request_asset(path) end

lyra-scripting/scripts/lua/types/globals.lua

@@ -1,5 +0,0 @@
----@meta
-
----The world global that is provided to every Lua script.
----@type World
-world = nil

lyra-scripting/scripts/lua/types/init.lua

@@ -1,10 +1,3 @@
 require "math.vec2"
-require "math.vec3"
-require "math.vec4"
-require "math.quat"
-require "math.transform"
 
 require "ecs.window"
-require "ecs.delta_time"
-
-require "asset.handle"

lyra-scripting/scripts/lua/types/math/quat.lua

@@ -1,188 +0,0 @@
----@meta
-
----@class Quat: userdata
----This is a Lua export of [`glam::Quat`](https://docs.rs/glam/latest/glam/f32/struct.Quat.html)
----
----@operator add(self): self
----@operator sub(self): self
----@operator div(number): self
----@operator mul(self|Vec3|number): self
----@diagnostic disable-next-line: unknown-operator
----@operator eq: self
-Quat = {
-    ---The x coordinate
-    ---@type number
-    x = nil,
-    
-    ---The y coordinate
-    ---@type number
-    y = nil,
-
-    ---The z coordinate
-    ---@type number
-    z = nil,
-
-    ---The w coordinate
-    ---@type number
-    w = nil,
-}
-
----Create a new `Quat`
----@param x number
----@param y number
----@param z number
----@param w number
----@return self
-function Quat.new(x, y, z, w) end
-
----Creates a quaternion from the angle (in radians) around the x axis.
----@param rad number
----@return self
-function Quat.from_rotation_x(rad) end
-
----Creates a quaternion from the angle (in radians) around the y axis.
----@param rad number
----@return self
-function Quat.from_rotation_y(rad) end
-
----Creates a quaternion from the angle (in radians) around the z axis.
----@param rad number
----@return self
-function Quat.from_rotation_z(rad) end
-
----Creates a quaternion from a `Vec4`.
----@param vec4 Vec4
----@return self
-function Quat.from_vec4(vec4) end
-
----Create a quaternion for a normalized rotation axis and angle (in radians).
----
----The axis must be a unit vector.
----
----@param axis Vec3
----@param rad number
----@return self
-function Quat.from_axis_angle(axis, rad) end
-
----Computes the dot product of self and rhs.
----
----The dot product is equal to the cosine of the angle between two
----quaternion rotations.
----
----@param rhs Quat
----@return number
-function Quat:dot(rhs) end
-
----Computes the length of self.
----
----@return number
-function Quat:length() end
-
----Computes the squared length of self.
----
----This is generally faster than length() as it avoids a square root operation.
----
----@return number
-function Quat:length_squared() end
-
----Computes 1.0 / length().
----
----For valid results, self must not be of length zero.
----@return number
-function length_recip() end
-
----Returns `self` normalized to length `1.0`.
----
----For valid results, `self` must not be of length zero.
----
----@return self
-function Quat:normalize() end
-
----Multipies `self` with a `Quat`
----@param rhs Quat
-function Quat:mult_quat(rhs) end
-
----Multiplies `self` with a `Vec3`
----@param rhs Vec3
-function Quat:mult_vec3(rhs) end
-
----Performs a linear interpolation between `self` and `rhs` based on `alpha`.
----
----Both `Quat`s must be normalized.
----
----When `alpha` is `0.0`, the result will be equal to `self`. When `alpha` is `1.0`,
----the result will be equal to `rhs`.
----
----@param rhs Quat
----@param alpha number
-function Quat:lerp(rhs, alpha) end
-
----Performs a spherical linear interpolation between `self` and `rhs` based on `alpha`.
----
----Both `Quat`s must be normalized.
----
----When `alpha` is `0.0`, the result will be equal to `self`. When `alpha` is `1.0`,
----the result will be equal to `rhs`.
----
----@param rhs Quat
----@param alpha number
-function Quat:slerp(rhs, alpha) end
-
-
----Returns the inverse of a normalized quaternion.
----
----Typically quaternion inverse returns the conjugate of a normalized quaternion.
----Because `self` is assumed to already be unit length this method does not
----normalize before returning the conjugate.
----@return self
-function Quat:inverse() end
-
----Returns `true` if, and only if, all elements are finite. If any element is either
----`NaN`, positive or negative infinity, this will return `false`.
----
----@return boolean
-function Quat:is_finite() end
-
----@return boolean
-function Quat:is_nan() end
-
----Returns whether `self` is of length `1.0` or not.
----
----Uses a precision threshold of `1e-6`.
----@return boolean
-function Quat:is_normalized() end
-
----@return boolean
-function Quat:is_near_identity() end
-
----Returns the angle (in radians) for the minimal rotation for transforming
----this quaternion into another.
----
----Both quaternions must be normalized.
----@return number
-function Quat:angle_between(rhs) end
-
----Rotates towards `rhs` up to `max_angle` (in radians).
----
----When `max_angle` is `0.0`, the result will be equal to `self`. When `max_angle`
----is equal to `self.angle_between(rhs)`, the result will be equal to `rhs`.
----If `max_angle` is negative, rotates towards the exact opposite of `rhs`.
----Will not go past the target.
----
----Both quaternions must be normalized.
----@return self
-function Quat:rotate_towards(rhs, max_angle) end
-
----Returns true if the absolute difference of all elements between `self` and `rhs` is less
----than or equal to `max_abs_diff`.
----
----This can be used to compare if two quaternions contain similar elements. It works best when
----comparing with a known value. The `max_abs_diff` that should be used used depends on the
----values being compared against.
----
----For more see [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).
----
----@param rhs Quat
----@param max_abs_diff number
----@return boolean
-function Quat:abs_diff_eq(rhs, max_abs_diff) end

lyra-scripting/scripts/lua/types/math/transform.lua

@@ -1,134 +0,0 @@
----@meta
-
----@class Transform: userdata
----
----A Transform represents a transformation of an object. A transform includes the position
----(called translation here), rotation, and scale. Rotation is represented using a Quaternion
----(or Quat for short).
----
----Although Quats can be scary, they are much more robust than euler angles for games
----since they do not suffer from things like
----[gimbal-lock](https://en.wikipedia.org/wiki/Gimbal_lock).
----
----This is a Lua export of [`lyra_math::Transform`].
----
----@operator add(Quat): self
----@operator mul(Vec3): self
----@diagnostic disable-next-line: unknown-operator
----@operator eq: self
-Transform = {
-    ---The translation/position of the transform.
-    ---@type Vec3
-    translation = nil,
-    ---The rotation of the transform.
-    ---@type Quat
-    rotation = nil,
-    ---The scale of the transform.
-    ---@type Vec3
-    scale = nil,
-}
-
-function Transform:__tostring() end
-
----@return self
-function Transform.default() end
-
----Create a new transform with its components.
----
----@param translation Vec3
----@param rotation Quat
----@param scale Vec3
----@return self
-function Transform.new(translation, rotation, scale) end
-
----Create a new transform with a `Vec3` translation.
----@param translation Vec3
----@return self
-function Transform.from_translation(translation) end
-
----Create a new transform with a translation of `x`, `y`, and `z`.
----
----@param x number
----@param y number
----@param z number
----@return self
-function Transform.from_translation(x, y, z) end
-
----Create a clone of `self`
----@return self
-function Transform:clone() end
-
----Returns a normalized vector pointing in the direction the Transform is facing.
----
----This represents the front of the object can be used for movement, camera orientation, and
----other directional calculations.
----
----@return Vec3
-function Transform:forward() end
-
----Returns a normalized vector pointing to the left side of the Transform.
----
----The vector is in local space. This represents the direction that is
----perpendicular to the object's forward direction.
----
----@return Vec3
-function Transform:left() end
-
----Returns a normalized vector that indicates the upward direction of the Transform.
----
----This vector is commonly used to define an object's orientation and is essential for maintaining
----consistent vertical alignment in 3D environments, such as for camera positioning and object alignment.
----@return Vec3
-function Transform:up() end
-
----Rotate `self` using a quaternion
----@param quat Quat
-function Transform:rotate(quat) end
-
----Rotate `self` around the x axis by **degrees**.
----
----@param deg number The amount of **degrees** to rotate by.
-function Transform:rotate_x(deg) end
-
----Rotate `self` around the y axis by **degrees**.
----
----@param deg number The amount of **degrees** to rotate by.
-function Transform:rotate_y(deg) end
-
----Rotate `self` around the z axis by **degrees**.
----
----@param deg number The amount of **degrees** to rotate by.
-function Transform:rotate_z(deg) end
-
----Rotate `self` around the x axis by **radians** .
----
----@param rad number The amount of **radians** to rotate by.
-function Transform:rotate_x_rad(rad) end
-
----Rotate `self` around the y axis by **radians** .
----
----@param rad number The amount of **radians** to rotate by.
-function Transform:rotate_y_rad(rad) end
-
----Rotate `self` around the z axis by **radians** .
----
----@param rad number The amount of **radians** to rotate by.
-function Transform:rotate_z_rad(rad) end
-
----Move `self` by `x`, `y`, and `z`.
----
----@param x number
----@param y number
----@param z number
-function Transform:translate(x, y, z) end
-
----Performs a linear interpolation between `self` and `rhs` based on `alpha`.
----
----This will normalize the rotation `Quat`.
----
----When `alpha` is `0.0`, the result will be equal to `self`. When `alpha` is `1.0`,
----the result will be equal to `rhs`.
----
----@param rhs Transform
----@param alpha number
-function Transform:lerp(rhs, alpha) end

lyra-scripting/scripts/lua/types/math/vec2.lua

@@ -1,125 +1,14 @@
----@meta
+---@class Vec2
-
----@class Vec2: userdata
----This is a Lua export of [`glam::Vec2`](https://docs.rs/glam/latest/glam/f32/struct.Vec2.html)
----
----@operator add(self|number): self
----@operator sub(self|number): self
----@operator div(self|number): self
----@operator mul(self|number): self
----@operator mod(self|number): self
----@operator unm: self
----@diagnostic disable-next-line: unknown-operator
----@operator eq: self
 Vec2 = {
     ---The x coordinate
     ---@type number
     x = nil,
-    
     ---The y coordinate
     ---@type number
     y = nil,
 
-    ---A constant `Vec2` with coordinates as `f32::NAN`.
-    ---@type Vec2
-    NAN = nil,
-
-    ---A constant `Vec2` with `x` as `-1.0`.
-    ---@type Vec2
-    NEG_X = nil,
-
-    ---A constant `Vec2` with `y` as `-1.0`.
-    ---@type Vec2
-    NEG_Y = nil,
-
-    ---A constant `Vec2` with both components as `-1.0`.
-    ---@type Vec2
-    NEG_ONE = nil,
-
-    ---A constant `Vec2` with `x` as `1.0`.
-    ---@type Vec2
-    POS_X = nil,
-
-    ---A constant `Vec2` with `y` as `1.0`.
-    ---@type Vec2
-    POS_Y = nil,
-
-    ---A constant `Vec2` with both components as `1.0`.
-    ---@type Vec2
-    ONE = nil,
-
-    ---A constant `Vec2` with both components as `0.0`.
-    ---@type Vec2
-    ZERO = nil,
-}
-
-function Vec2:__tostring() end
-
     ---Create a new `Vec2`
     ---@param x number
     ---@param y number
----@return self
+    new = function (x, y) end
-function Vec2.new(x, y) end
+}
-
----Returns a vector with a length no less than min and no more than max.
----@param min number the minimum value to clamp the length to
----@param max number the maximum value to clamp the length to
----@return self
-function Vec2:clamp_length(min, max) end
-
----Returns true if the absolute difference of all elements between `self` and `rhs` is less
----than or equal to `max_abs_diff`.
----
----This can be used to compare if two vectors contain similar elements. It works best when
----comparing with a known value. The `max_abs_diff` that should be used used depends on the
----values being compared against.
----
----For more see [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).
----
----@param rhs Vec2 The other `Vec2` to compare to.
----@param max_abs_diff number Maximum absolute difference between `self` and `rhs`.
----@return boolean
-function Vec2:abs_diff_eq(rhs, max_abs_diff) end
-
----Returns a vector containing the smallest integer greater than or equal to a number for each
----element of self.
----@return self
-function Vec2:ceil() end
-
----Returns the angle of rotation (in radians) from `self` to `rhs` in the range [-π, +π].
----
----The inputs do not need to be unit vectors however they must be non-zero.
----
----@param rhs Vec2 The other `Vec2` to get the angle to.
----@return number
-function Vec2:angle_to(rhs) end
-
----Returns a vector containing the absolute value of each element of `self`.
----
----@return self
-function Vec2:abs() end
-
----Component-wise clamping of values.
----
----Each element in `min` must be less-or-equal to the corresponding element in `max`.
----
----@param min self The minimum `Vec2` components to clamp the components of `self` to.
----@param max self The maximum `Vec2` components to clamp the components of `self` to.
----@return self
-function Vec2:clamp(min, max) end
-
----Converts `self` to an array `[x, y]`
----
----@return number[]
-function Vec2:to_array() end
-
----Move `self` by `x` and `y` values.
----
----@param x number
----@param y number
-function Vec2:move_by(x, y) end
-
----Move `self` by a `Vec2`.
----
----@param rhs Vec2
-function Vec2:move_by(rhs) end

lyra-scripting/scripts/lua/types/math/vec3.lua

@@ -1,139 +0,0 @@
----@meta
-
----@class Vec3: userdata
----This is a Lua export of [`glam::Vec3`](https://docs.rs/glam/latest/glam/f32/struct.Vec3.html)
----
----@operator add(self|number): self
----@operator sub(self|number): self
----@operator div(self|number): self
----@operator mul(self|number): self
----@operator mod(self|number): self
----@operator unm: self
----@diagnostic disable-next-line: unknown-operator
----@operator eq: self
-Vec3 = {
-    ---The x coordinate
-    ---@type number
-    x = nil,
-    
-    ---The y coordinate
-    ---@type number
-    y = nil,
-
-    ---The z coordinate
-    ---@type number
-    z = nil,
-
-    ---A constant `Vec3` with coordinates as `f32::NAN`.
-    ---@type Vec3
-    NAN = nil,
-
-    ---A constant `Vec3` with `x` as `-1.0`.
-    ---@type Vec3
-    NEG_X = nil,
-
-    ---A constant `Vec3` with `y` as `-1.0`.
-    ---@type Vec3
-    NEG_Y = nil,
-
-    ---A constant `Vec3` with `z` as `-1.0`.
-    ---@type Vec3
-    NEG_Z = nil,
-
-    ---A constant `Vec3` with all components as `-1.0`.
-    ---@type Vec3
-    NEG_ONE = nil,
-
-    ---A constant `Vec3` with `x` as `1.0`.
-    ---@type Vec3
-    POS_X = nil,
-
-    ---A constant `Vec3` with `y` as `1.0`.
-    ---@type Vec3
-    POS_Y = nil,
-
-    ---A constant `Vec3` with `z` as `1.0`.
-    ---@type Vec3
-    POS_Z = nil,
-
-    ---A constant `Vec3` with all components as `1.0`.
-    ---@type Vec3
-    ONE = nil,
-
-    ---A constant `Vec3` with all components as `0.0`.
-    ---@type Vec3
-    ZERO = nil,
-}
-
-function Vec3:__tostring() end
-
----Create a new `Vec3`
----@param x number
----@param y number
----@param z number
----@return self
-function Vec3.new(x, y, z) end
-
----Returns a vector with a length no less than min and no more than max.
----@param min number the minimum value to clamp the length to
----@param max number the maximum value to clamp the length to
----@return self
-function Vec3:clamp_length(min, max) end
-
----Returns true if the absolute difference of all elements between `self` and `rhs` is less
----than or equal to `max_abs_diff`.
----
----This can be used to compare if two vectors contain similar elements. It works best when
----comparing with a known value. The `max_abs_diff` that should be used used depends on the
----values being compared against.
----
----For more see [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).
----
----@param rhs Vec3 The other `Vec3` to compare to.
----@param max_abs_diff number Maximum absolute difference between `self` and `rhs`.
----@return boolean
-function Vec3:abs_diff_eq(rhs, max_abs_diff) end
-
----Returns a vector containing the smallest integer greater than or equal to a number for each
----element of self.
----@return self
-function Vec3:ceil() end
-
----Returns the angle (in radians) between two vectors in the range [-π, +π].
----
----The inputs do not need to be unit vectors however they must be non-zero.
----
----@param rhs Vec3 The other `Vec3` to get the angle to.
----@return number
-function Vec3:angle_between(rhs) end
-
----Returns a vector containing the absolute value of each element of `self`.
----
----@return self
-function Vec3:abs() end
-
----Component-wise clamping of values.
----
----Each element in `min` must be less-or-equal to the corresponding element in `max`.
----
----@param min self The minimum `Vec3` components to clamp the components of `self` to.
----@param max self The maximum `Vec3` components to clamp the components of `self` to.
----@return self
-function Vec3:clamp(min, max) end
-
----Converts `self` to an array `[x, y, z]`
----
----@return number[]
-function Vec3:to_array() end
-
----Move `self` by `x`, `y`, and `z` values.
----
----@param x number
----@param y number
----@param z number
-function Vec3:move_by(x, y, z) end
-
----Move `self` by a `Vec3`.
----
----@param rhs Vec3
-function Vec3:move_by(rhs) end

lyra-scripting/scripts/lua/types/math/vec4.lua

@@ -1,132 +0,0 @@
----@meta
-
----@class Vec4: userdata
----This is a Lua export of [`glam::Vec4`](https://docs.rs/glam/latest/glam/f32/struct.Vec4.html)
----
----@operator add(self|number): self
----@operator sub(self|number): self
----@operator div(self|number): self
----@operator mul(self|number): self
----@operator mod(self|number): self
----@operator unm: self
----@diagnostic disable-next-line: unknown-operator
----@operator eq: self
-Vec4 = {
-    ---The x coordinate
-    ---@type number
-    x = nil,
-    
-    ---The y coordinate
-    ---@type number
-    y = nil,
-
-    ---The z coordinate
-    ---@type number
-    z = nil,
-
-    ---The w coordinate
-    ---@type number
-    w = nil,
-
-    ---A constant `Vec4` with coordinates as `f32::NAN`.
-    ---@type Vec4
-    NAN = nil,
-
-    ---A constant `Vec4` with `x` as `-1.0`.
-    ---@type Vec4
-    NEG_X = nil,
-
-    ---A constant `Vec4` with `y` as `-1.0`.
-    ---@type Vec4
-    NEG_Y = nil,
-
-    ---A constant `Vec4` with `z` as `-1.0`.
-    ---@type Vec4
-    NEG_Z = nil,
-
-    ---A constant `Vec4` with `w` as `-1.0`.
-    ---@type Vec4
-    NEG_W = nil,
-
-    ---A constant `Vec4` with all components as `-1.0`.
-    ---@type Vec4
-    NEG_ONE = nil,
-
-    ---A constant `Vec4` with `x` as `1.0`.
-    ---@type Vec4
-    POS_X = nil,
-
-    ---A constant `Vec4` with `y` as `1.0`.
-    ---@type Vec4
-    POS_Y = nil,
-
-    ---A constant `Vec4` with `z` as `1.0`.
-    ---@type Vec4
-    POS_Z = nil,
-
-    ---A constant `Vec4` with `w` as `1.0`.
-    ---@type Vec4
-    POS_W = nil,
-
-    ---A constant `Vec4` with all components as `1.0`.
-    ---@type Vec4
-    ONE = nil,
-
-    ---A constant `Vec4` with all components as `0.0`.
-    ---@type Vec4
-    ZERO = nil,
-}
-
-function Vec4:__tostring() end
-
----Create a new `Vec4`
----@param x number
----@param y number
----@param z number
----@param w number
----@return self
-function Vec4.new(x, y, z, w) end
-
----Returns a vector with a length no less than min and no more than max.
----@param min number the minimum value to clamp the length to
----@param max number the maximum value to clamp the length to
----@return self
-function Vec4:clamp_length(min, max) end
-
----Returns true if the absolute difference of all elements between `self` and `rhs` is less
----than or equal to `max_abs_diff`.
----
----This can be used to compare if two vectors contain similar elements. It works best when
----comparing with a known value. The `max_abs_diff` that should be used used depends on the
----values being compared against.
----
----For more see [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).
----
----@param rhs Vec4 The other `Vec4` to compare to.
----@param max_abs_diff number Maximum absolute difference between `self` and `rhs`.
----@return boolean
-function Vec4:abs_diff_eq(rhs, max_abs_diff) end
-
----Returns a vector containing the smallest integer greater than or equal to a number for each
----element of self.
----@return self
-function Vec4:ceil() end
-
----Returns a vector containing the absolute value of each element of `self`.
----
----@return self
-function Vec4:abs() end
-
----Component-wise clamping of values.
----
----Each element in `min` must be less-or-equal to the corresponding element in `max`.
----
----@param min self The minimum `Vec4` components to clamp the components of `self` to.
----@param max self The maximum `Vec4` components to clamp the components of `self` to.
----@return self
-function Vec4:clamp(min, max) end
-
----Converts `self` to an array `[x, y, z]`
----
----@return number[]
-function Vec4:to_array() end

lyra-scripting/src/lua/providers/ecs.rs

@@ -40,18 +40,14 @@ impl ScriptApiProvider for LyraEcsApiProvider {
     fn expose_api(&mut self, _: &ScriptData, ctx: &mut Self::ScriptContext) -> Result<(), crate::ScriptError> {
         let ctx = ctx.lock().unwrap();
 
-        // load window enums
+        // load window util
         let bytes = include_str!("../../../scripts/lua/window.lua");
         ctx.load(bytes).exec().unwrap();
 
-        // load asset handle enums
-        let bytes = include_str!("../../../scripts/lua/asset_handle.lua");
-        ctx.load(bytes).exec().unwrap();
-
         let globals = ctx.globals();
         globals.set("World", ctx.create_proxy::<ScriptWorldPtr>()?)?;
         globals.set("DynamicBundle", ctx.create_proxy::<ScriptDynamicBundle>()?)?;
-        globals.set("SceneHandler", ctx.create_proxy::<LuaSceneHandle>()?)?;
+        globals.set("SceneComponent", ctx.create_proxy::<LuaSceneHandle>()?)?;
         globals.set("ActionHandler", ctx.create_proxy::<LuaActionHandler>()?)?;
         globals.set("Window", ctx.create_proxy::<LuaWindow>()?)?;
 

lyra-scripting/src/lua/world.rs

@@ -294,7 +294,7 @@ impl mlua::UserData for ScriptWorldPtr {
 
             Ok(())
         });
-        methods.add_method_mut("request_asset", |lua, this, path: String| {
+        methods.add_method_mut("request_res", |lua, this, path: String| {
             let world = this.write();
             let man = world.get_resource_mut::<ResourceManager>().unwrap();
             let handle = man.request_raw(&path).unwrap();

lyra-scripting/src/lua/wrappers/asset/mod.rs

@@ -111,12 +111,9 @@ impl mlua::FromLua for LuaResHandle {
     }
 }
 
-// TODO: fields
 wrap_lua_struct!(lyra_resource::gltf::PbrGlossiness, skip(lua_reflect)); // doesn't need internal lua reflection methods
-// TODO: fields
 wrap_lua_struct!(lyra_resource::gltf::Specular, skip(lua_reflect)); // doesn't need internal lua reflection methods
 
-// TODO: fields
 lua_wrap_handle!(SceneGraph, name=Scene, {});
 
 lua_wrap_handle!(Mesh, 

lyra-scripting/src/lua/wrappers/input_actions.rs

@@ -127,21 +127,13 @@ impl mlua::UserData for LuaActionHandler {
         methods.add_method("get_action_state", |lua, this, action: String| {
             let state = this.handler.get_action_state(action);
 
-            // if the state wasn't found, return Nil.
-            if state.is_none() {
-                let mut v = mlua::MultiValue::new();
-                v.push_back(mlua::Value::Nil);
-                return Ok(v);
-            }
-
-            let state = state.unwrap();
             let (name, val) = match state {
-                ActionState::Idle => ("idle", None),
+                ActionState::Idle => ("Idle", None),
-                ActionState::Pressed(v) => ("pressed", Some(v)),
+                ActionState::Pressed(v) => ("Pressed", Some(v)),
-                ActionState::JustPressed(v) => ("just_pressed", Some(v)),
+                ActionState::JustPressed(v) => ("JustPressed", Some(v)),
-                ActionState::JustReleased => ("just_released", None),
+                ActionState::JustReleased => ("JustReleased", None),
-                ActionState::Axis(v) => ("axis", Some(v)),
+                ActionState::Axis(v) => ("Axis", Some(v)),
-                ActionState::Other(v) => ("other", Some(v)),
+                ActionState::Other(v) => ("Other", Some(v)),
             };
 
             let mut multi = Vec::new();

lyra-scripting/src/lua/wrappers/math.rs

@@ -1,6 +1,4 @@
-use std::sync::Arc;
+use crate::lyra_engine;
-
-use crate::{lua::Error, lyra_engine};
 use lyra_game::math;
 use lyra_scripting_derive::{lua_vec_wrap_extension, wrap_lua_struct};
 use mlua::FromLuaMulti;
@@ -31,14 +29,7 @@ wrap_lua_struct!(
             } else if let Ok(v) = Self::from_lua_multi(vals_clone, lua) {
                 this.0 += v.0;
             } else {
-                return Err(mlua::Error::BadArgument {
+                todo!("handle invalid argument error");
-                    to: Some("Vec2:move_by".into()),
-                    pos: 2,
-                    name: None,
-                    cause: Arc::new(mlua::Error::runtime(
-                        "expected (number, number, number) or (Vec2), received neither"
-                    )),
-                });
             }
 
             Ok(())
@@ -71,14 +62,7 @@ wrap_lua_struct!(
             } else if let Ok(v) = Self::from_lua_multi(vals_clone, lua) {
                 this.0 += v.0;
             } else {
-                return Err(mlua::Error::BadArgument {
+                todo!("handle invalid argument error");
-                    to: Some("Vec3:move_by".into()),
-                    pos: 2,
-                    name: None,
-                    cause: Arc::new(mlua::Error::runtime(
-                        "expected (number, number, number) or (Vec3), received neither"
-                    )),
-                });
             }
 
             Ok(())
@@ -138,27 +122,10 @@ wrap_lua_struct!(
             Ok(Self(q))
         });
 
-        methods.add_function("from_vec4", |_, v: LuaVec4| {
-            Ok(Self(math::Quat::from_vec4(*v)))
-        });
-
-        methods.add_function("from_axis_angle", |_, (axis, angle): (LuaVec3, f32)| {
-            let q = math::Quat::from_axis_angle(*axis, angle);
-            Ok(Self(q))
-        });
-
         methods.add_method("dot", |_, this, (rhs,): (Self,)| {
             Ok(this.dot(rhs.0))
         });
 
-        methods.add_method("conjugate", |_, this, ()| {
-            Ok(Self(this.conjugate()))
-        });
-
-        methods.add_method("inverse", |_, this, ()| {
-            Ok(Self(this.inverse()))
-        });
-
         methods.add_method("length", |_, this, ()| {
             Ok(this.length())
         });
@@ -167,50 +134,20 @@ wrap_lua_struct!(
             Ok(this.length_squared())
         });
 
-        methods.add_method("length_recip", |_, this, ()| {
+        methods.add_method_mut("normalize", |_, this, ()| {
-            Ok(this.length_recip())
+            this.0 = this.normalize();
+            Ok(())
         });
 
-        methods.add_method("normalize", |_, this, ()| {
+        methods.add_method_mut("mult_quat", |_, this, (rhs,): (Self,)| {
-            Ok(Self(this.normalize()))
+            this.0 *= rhs.0;
-        });
+            Ok(())
-
-        methods.add_method("mult_quat", |_, this, (rhs,): (Self,)| {
-            Ok(Self(this.0 * rhs.0))
         });
 
         methods.add_method("mult_vec3", |_, this, (rhs,): (LuaVec3,)| {
             Ok(LuaVec3(this.0 * rhs.0))
         });
 
-        methods.add_method("is_finite", |_, this, ()| {
-            Ok(this.is_finite())
-        });
-
-        methods.add_method("is_nan", |_, this, ()| {
-            Ok(this.is_nan())
-        });
-
-        methods.add_method("is_normalized", |_, this, ()| {
-            Ok(this.is_normalized())
-        });
-
-        methods.add_method("is_near_identity", |_, this, ()| {
-            Ok(this.is_near_identity())
-        });
-
-        methods.add_method("angle_between", |_, this, rhs: LuaQuat| {
-            Ok(this.angle_between(*rhs))
-        });
-
-        methods.add_method("rotate_towards", |_, this, (rhs, max_angle): (LuaQuat, f32)| {
-            Ok(Self(this.rotate_towards(*rhs, max_angle)))
-        });
-
-        methods.add_method("abs_diff_eq", |_, this, (rhs, max_abs_diff): (LuaQuat, f32)| {
-            Ok(this.abs_diff_eq(*rhs, max_abs_diff))
-        });
-
         // manually implemented here since multiplying may not return `Self`.
         methods.add_meta_method(mlua::MetaMethod::Mul, |lua, this, (val,): (mlua::Value,)| {
             use mlua::IntoLua;
@@ -232,15 +169,7 @@ wrap_lua_struct!(
                         .into_lua(lua)
                 },
                 _ => {
-                    let t = val.type_name();
+                    todo!()
-                    Err(mlua::Error::BadArgument {
-                        to: Some("Quat:__mul".into()),
-                        pos: 2,
-                        name: None,
-                        cause: Arc::new(mlua::Error::external(
-                            Error::type_mismatch("Vec3, Quat, or Number", t)
-                        )),
-                    })
                 }
             }
         });
@@ -248,10 +177,6 @@ wrap_lua_struct!(
         methods.add_method("lerp", |_, this, (rhs, alpha): (Self, f32)| {
             Ok(Self(this.lerp(*rhs, alpha)))
         });
-
-        methods.add_method("slerp", |_, this, (rhs, alpha): (Self, f32)| {
-            Ok(Self(this.slerp(*rhs, alpha)))
-        });
     }
 );
 
@@ -268,22 +193,12 @@ wrap_lua_struct!(
             Ok(Self(math::Transform::new(*pos, *rot, *scale)))
         });
 
-        methods.add_function("from_translation", |lua, vals: mlua::MultiValue| {
+        methods.add_function("from_translation", |_, (pos,): (LuaVec3,)| {
-            let vals_clone = vals.clone();
+            Ok(Self(math::Transform::from_translation(*pos)))
-            if let Ok((x, y, z)) = <(f32, f32, f32) as FromLuaMulti>::from_lua_multi(vals, lua) {
+        });
+
+        methods.add_function("from_xyz", |_, (x, y, z)| {
             Ok(Self(math::Transform::from_xyz(x, y, z)))
-            } else if let Ok(v) = LuaVec3::from_lua_multi(vals_clone, lua) {
-                Ok(Self(math::Transform::from_translation(*v)))
-            } else {
-                Err(mlua::Error::BadArgument {
-                    to: Some("Transform:from_translation".into()),
-                    pos: 2,
-                    name: None,
-                    cause: Arc::new(mlua::Error::runtime(
-                        "expected (number, number, number) or (Vec3), received neither"
-                    )),
-                })
-            }
         });
 
         methods.add_method("clone", |_, this, ()| {