examples/lua-scripting/scripts/test.lua

@@ -14,19 +14,6 @@ function udname(val)
 
     return tbl.__name
 end
-
-function dump(o)
-    if type(o) == 'table' then
-       local s = '{ '
-       for k,v in pairs(o) do
-          if type(k) ~= 'number' then k = '"'..k..'"' end
-          s = s .. '['..k..'] = ' .. dump(v) .. ','
-       end
-       return s .. '} '
-    else
-       return tostring(o)
-    end
- end
  
 
 function on_init()
@@ -59,17 +46,6 @@ function on_first()
             end, Window
         )
     end
-
-    ---@type EventReader
-    local reader = world:read_event(DeviceEvent)
-
-    ---@param ev DeviceEvent
-    for ev in reader:read() do
-        if ev.event.kind == DeviceEventKind.MOTION then
-            local motion_ev = ev.event --[[@as DeviceEventMotion]]
-            print("axis: " .. tostring(motion_ev.axis) .. " = " .. tostring(motion_ev.value))
-        end
-    end
 end
 
 --[[ function on_pre_update()

lyra-game/src/event.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{cell::RefCell, rc::Rc, sync::Arc};
 
 use atomic_refcell::AtomicRefCell;
 use lyra_ecs::{query::{ResMut, WorldTick}, system::FnArgFetcher, Tick};
@@ -99,7 +99,7 @@ impl<T: Event> Events<T> {
     pub fn reader(&self) -> EventReader<T> {
         EventReader {
             events: self.events.clone(),
-            cursor: Arc::new(AtomicRefCell::new(0)),
+            cursor: Rc::new(RefCell::new(0)),
         }
     }
 
@@ -112,11 +112,11 @@ impl<T: Event> Events<T> {
 
 pub struct EventReader<T: Event> {
     events: Arc<AtomicRefCell<WaterfallVec<T>>>,
-    cursor: Arc<AtomicRefCell<usize>>,
+    cursor: Rc<RefCell<usize>>,
 }
 
 impl<T: Event> EventReader<T> {
-    pub fn read(&self) -> Option<atomic_refcell::AtomicRef<T>> {
+    pub fn read(&mut self) -> Option<atomic_refcell::AtomicRef<T>> {
         let events = self.events.borrow();
         
         let mut cursor = self.cursor.borrow_mut();
@@ -136,7 +136,7 @@ pub struct EventWriter<T: Event> {
 }
 
 impl<T: Event> EventWriter<T> {
-    pub fn write(&self, event: T) {
+    pub fn write(&mut self, event: T) {
         let mut events = self.events.borrow_mut();
         events.push(event);
     }
@@ -167,12 +167,12 @@ where
 }
 
 impl<T: Event> FnArgFetcher for EventReader<T> {
-    type State = Arc<AtomicRefCell<usize>>;
+    type State = Rc<RefCell<usize>>;
 
     type Arg<'a, 'state> = EventReader<T>;
 
     fn create_state(_: std::ptr::NonNull<lyra_ecs::World>) -> Self::State {
-        Arc::new(AtomicRefCell::new(0))
+        Rc::new(RefCell::new(0))
     }
 
     unsafe fn get<'a, 'state>(state: &'state mut Self::State, world: std::ptr::NonNull<lyra_ecs::World>) -> Self::Arg<'a, 'state> {

lyra-game/src/input/mod.rs

@@ -520,8 +520,7 @@ impl KeyCode {
     pub fn as_physical_key(&self) -> winit::keyboard::PhysicalKey {
         match self {
             KeyCode::Unknown(v) => winit::keyboard::PhysicalKey::Unidentified((*v).into()),
-            // unwrap is safe here since we know self is not an `Unknown` key.
-            _ => winit::keyboard::PhysicalKey::Code(self.as_winit_keycode().unwrap())
+            _ => winit::keyboard::PhysicalKey::Code(self.into())
         }
     }
 

lyra-game/src/input/system.rs

@@ -6,7 +6,7 @@ use winit::{event::{MouseScrollDelta, WindowEvent}, keyboard::PhysicalKey};
 
 use crate::{game::GameStages, plugin::Plugin, winit::DeviceEventPair, EventReader, EventWriter};
 
-use super::{events::*, InputButtons, KeyCode};
+use super::{events::*, InputButtons};
 
 fn write_scroll_delta(mouse_scroll_ev: &mut EventWriter<MouseScroll>, delta: &MouseScrollDelta) {
     let event = match delta {
@@ -21,24 +21,24 @@ fn write_scroll_delta(mouse_scroll_ev: &mut EventWriter<MouseScroll>, delta: &Mo
     mouse_scroll_ev.write(event);
 }
 
-fn write_key_event(key_buttons: &mut ResMut<InputButtons<KeyCode>>, physical_key: PhysicalKey, state: winit::event::ElementState) {
+fn write_key_event(key_buttons: &mut ResMut<InputButtons<winit::keyboard::KeyCode>>, physical_key: winit::keyboard::PhysicalKey, state: winit::event::ElementState) {
     if let PhysicalKey::Code(code) = physical_key {
-        key_buttons.add_input_from_winit(KeyCode::from(code), state);
+        key_buttons.add_input_from_winit(code, state);
     }
 }
 
 pub fn input_system(
-    mut key_code_res: ResMut<InputButtons<KeyCode>>,
+    mut key_code_res: ResMut<InputButtons<winit::keyboard::KeyCode>>,
     mut mouse_btn_res: ResMut<InputButtons<MouseButton>>,
     mut touches_res: ResMut<Touches>,
-    window_ev: EventReader<WindowEvent>,
-    device_ev: EventReader<DeviceEventPair>,
+    mut window_ev: EventReader<WindowEvent>,
+    mut device_ev: EventReader<DeviceEventPair>,
     mut mouse_scroll_ev: EventWriter<MouseScroll>,
-    mouse_btn_ev: EventWriter<MouseButton>,
-    mouse_exact_ev: EventWriter<MouseExact>,
-    mouse_entered_ev: EventWriter<CursorEnteredWindow>,
-    mouse_left_ev: EventWriter<CursorLeftWindow>,
-    mouse_motion_ev: EventWriter<MouseMotion>,
+    mut mouse_btn_ev: EventWriter<MouseButton>,
+    mut mouse_exact_ev: EventWriter<MouseExact>,
+    mut mouse_entered_ev: EventWriter<CursorEnteredWindow>,
+    mut mouse_left_ev: EventWriter<CursorLeftWindow>,
+    mut mouse_motion_ev: EventWriter<MouseMotion>,
 ) -> anyhow::Result<()> {
     while let Some(event) = window_ev.read() {
         match event.deref() {
@@ -122,7 +122,7 @@ pub struct InputPlugin;
 
 impl Plugin for InputPlugin {
     fn setup(&mut self, app: &mut crate::game::App) {
-        app.add_resource(InputButtons::<KeyCode>::default());
+        app.add_resource(InputButtons::<winit::keyboard::KeyCode>::default());
         app.add_resource(InputButtons::<MouseButton>::default());
         app.add_resource(Touches::default());
         

lyra-game/src/winit/plugin.rs

@@ -13,7 +13,7 @@ use winit::{
     window::{Window, WindowAttributes, WindowId},
 };
 
-pub use winit::event::{DeviceId, DeviceEvent, MouseScrollDelta, ElementState, RawKeyEvent};
+pub use winit::event::{DeviceId, DeviceEvent, MouseScrollDelta, ElementState};
 pub use winit::keyboard::PhysicalKey;
 
 use crate::{

lyra-scripting/lyra-scripting-derive/src/handle_macro.rs

@@ -257,13 +257,5 @@ pub(crate) fn lua_wrap_handle_impl(input: proc_macro::TokenStream) -> proc_macro
                 self.0
             }
         }
-
-        impl LuaHandleWrapper for #wrapper_name {
-            type ResourceType = #handle_path;
-
-            fn from_handle(handle: ResHandle<Self::ResourceType>) -> Self {
-                Self(handle)
-            }
-        }
     }.into()
 }

lyra-scripting/scripts/lua/enums.lua

@@ -66,29 +66,4 @@ WrappingMode = {
 CameraProjectionMode = {
     PERSPECTIVE = "perspective",
     ORTHOGRAPHIC = "orthographic",
-}
-
----@enum DeviceEventKind
-DeviceEventKind = {
-    ADDED = "added",
-    REMOVED = "removed",
-    MOUSE_MOTION = "mouse_motion",
-    MOUSE_WHEEL = "mouse_wheel",
-    MOTION = "motion",
-    BUTTON = "button",
-    KEY = "key",
-}
-
----@enum NativeKeyCodeKind
-NativeKeyCodeKind = {
-    ANDROID = "android",
-    MACOS = "macos",
-    WINDOWS = "windows",
-    XKB = "xkb",
-}
-
----@enum ElementState
-ElementState = {
-    PRESSED = "pressed",
-    RELEASED = "released",
 }

lyra-scripting/scripts/lua/types/events/device.lua

@@ -1,140 +0,0 @@
----@meta
-
----@class DeviceEventAdded: table
-DeviceEventAdded = {
-    ---@type DeviceEventKind
-    kind = DeviceEventKind.ADDED,
-}
-
----@class DeviceEventRemoved: table
-DeviceEventRemoved = {
-    ---@type DeviceEventKind
-    kind = DeviceEventKind.REMOVED,
-}
-
----@class DeviceEventMouseMotion: table
-DeviceEventMouseMotion = {
-    ---@type DeviceEventKind
-    kind = DeviceEventKind.MOUSE_MOTION,
-
-    ---The change in physical position of a pointing device.
-    ---
-    ---This represents raw, unfiltered physical motion.
-    ---
-    ---@type Vec2
-    delta = nil,
-}
-
----A physical scroll event from a device.
----
----`line_delta` and `pixel_delta` are exclusive, only one is non-nil at a time.
----
----@class DeviceEventMouseWheel: table
-DeviceEventMouseWheel = {
-    ---@type DeviceEventKind
-    kind = DeviceEventKind.MOUSE_WHEEL,
-
-    ---Amount in lines or rows to scroll.
-    ---
-    ---Positive values indicate that the content that is being scrolled should move right
-    ---and down (revealing more content left and up).
-    ---
-    ---@type Vec2?
-    line_delta = nil,
-
-    ---Amount in pixels to scroll in the horizontal and vertical direction.
-    ---
-    ---Positive values indicate that the content being scrolled should move right/down.
-    ---
-    ---@type Vec2?
-    pixel_delta = nil,
-}
-
----Device event that was triggered by motion on an analog axis.
----@class DeviceEventMotion: table
-DeviceEventMotion = {
-    ---@type DeviceEventKind
-    kind = DeviceEventKind.MOTION,
-
-    ---The analog axis that motion was triggered from.
-    ---@type number
-    axis = nil,
-
-    ---The amount of motion.
-    ---@type number
-    value = nil,
-}
-
----@class DeviceEventButton: table
-DeviceEventButton = {
-    ---@type DeviceEventKind
-    kind = DeviceEventKind.BUTTON,
-
-    ---The button id that the event is from.
-    ---@type number
-    button = nil,
-
-    ---The state of the button.
-    ---@type ElementState
-    state = nil,
-}
-
----A device event triggered from a key press.
----
----The field `code` will be nil if the key code identifier is unknown.
----When the identifier is unknown, it can be retrieved with `native_code`. The field
----`native` specifies the kind of platform the code is from.
----
----@class DeviceEventKey: table
-DeviceEventKey = {
-    ---@type DeviceEventKind
-    kind = DeviceEventKind.KEY,
-
-    ---@type ElementState
-    state = nil,
-    
-    ---The known key name.
-    ---
-    ---This is `nil` if `native` or `native_code` is specified.
-    ---
-    ---@type string
-    code = nil,
-
-    ---The kind of native platform this code is for.
-    ---
-    ---This is `nil` if `code` is specified.
-    ---
-    ---@type NativeKeyCodeKind
-    native = nil,
-    
-    ---The platform-native physical key identifier.
-    ---
-    ---This is `nil` if `code` is specified.
-    ---
-    ---@type number
-    native_code = nil,
-}
-
----@alias DeviceEventRaw
----| DeviceEventAdded
----| DeviceEventRemoved
----| DeviceEventMotion
----| DeviceEventMouseMotion
----| DeviceEventMouseWheel
----| DeviceEventButton
----| DeviceEventKey
-DeviceEventRaw = { }
-
----@class DeviceId: userdata
-DeviceId  = {}
-
----@class DeviceEvent: table
-DeviceEvent = {
-    ---The device id that the event came from
-    ---@type DeviceId
-    source = nil,
-    ---The actual device event
-    ---@type DeviceEventRaw
-    event = nil,
-}
-

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

@@ -1,18 +0,0 @@
----@meta
-
----@class EventReader: userdata
-EventReader = {}
-
----Returns an iterator over the events in the reader.
----@return fun(): any
-function EventReader:read() end
-
----@class EventWriter: userdata
-EventWriter = {}
-
----Writes an event.
----
----The event must be the same type that this writer wraps.
----
----@param event any
-function EventWriter:write(event) end

lyra-scripting/src/lua/mod.rs

@@ -2,7 +2,6 @@ pub mod dynamic_iter;
 pub use dynamic_iter::*;
 
 pub mod world;
-use lyra_resource::ResourceData;
 use mlua::ObjectLike;
 pub use world::*;
 
@@ -20,12 +19,11 @@ pub use proxy::*;
 
 pub mod system;
 pub use system::*;
-use wrappers::{LuaHandleWrapper, LuaResHandleToComponent, LuaWrappedEventProxy};
 
 use std::{any::TypeId, sync::Mutex};
 
 use lyra_ecs::World;
-use lyra_reflect::{FromType, Reflect, TypeRegistry};
+use lyra_reflect::{Reflect, TypeRegistry};
 use crate::ScriptBorrow;
 
 pub type LuaContext = Mutex<mlua::Lua>;
@@ -142,27 +140,10 @@ pub trait RegisterLuaType {
         T: Clone + mlua::FromLua + mlua::IntoLua + LuaWrapper + 'static,
         T::Wrap: lyra_ecs::Component + Reflect;
 
-    /// Register an asset handle wrapper.
-    fn register_asset_handle<T>(&mut self, name: &str)
-    where
-        T: LuaHandleWrapper + Reflect + LuaProxy,
-        T::ResourceType: ResourceData;
-
-    /// Add an entry for a non-component in the [`TypeLookup`] table.
-    fn add_lua_event<T>(&mut self, name: &str)
-    where
-        T: Reflect + LuaWrapper + mlua::FromLua + mlua::IntoLua + Send + Sync,
-        T::Wrap: Clone + lyra_game::Event;
-
     /// Add an entry for a component in the [`TypeLookup`] table.
     fn add_component_lookup_entry<T>(&mut self, name: &str)
     where
         T: lyra_ecs::Component;
-
-    /// Add an entry for a non-component in the [`TypeLookup`] table.
-    fn add_lookup_entry<T>(&mut self, name: &str)
-    where
-        T: 'static;
 }
 
 impl RegisterLuaType for World {
@@ -207,37 +188,6 @@ impl RegisterLuaType for World {
         self.add_component_lookup_entry::<T::Wrap>(name);
     }
 
-    fn register_asset_handle<T>(&mut self, name: &str)
-    where
-        T: LuaHandleWrapper + Reflect + LuaProxy,
-        T::ResourceType: ResourceData
-    {
-        {
-            let mut registry = self.get_resource_mut::<TypeRegistry>().unwrap();
-            let reg_type = registry.get_type_or_default(TypeId::of::<T::ResourceType>());
-            reg_type.add_data(ReflectLuaProxy::from_lua_proxy::<T>());
-            let l: LuaResHandleToComponent = FromType::<T>::from_type();
-            reg_type.add_data(l);
-        }
-
-        self.add_lookup_entry::<T>(name);
-    }
-
-    fn add_lua_event<T>(&mut self, name: &str)
-    where
-        T: Reflect + LuaWrapper + mlua::FromLua + mlua::IntoLua + Send + Sync,
-        T::Wrap: Clone + lyra_game::Event
-    {
-        {
-            let mut registry = self.get_resource_mut::<TypeRegistry>().unwrap();
-            let reg_type = registry.get_type_or_default(TypeId::of::<T::Wrap>());
-            let proxy: LuaWrappedEventProxy = FromType::<T>::from_type();
-            reg_type.add_data(proxy);
-        }
-
-        self.add_lookup_entry::<T::Wrap>(name);
-    }
-
     fn add_component_lookup_entry<T>(&mut self, name: &str)
     where
         T: lyra_ecs::Component
@@ -246,14 +196,6 @@ impl RegisterLuaType for World {
         lookup.comp_info_from_name.insert(name.into(), lyra_ecs::ComponentInfo::new::<T>());
         lookup.typeid_from_name.insert(name.into(), std::any::TypeId::of::<T>());
     }
-
-    fn add_lookup_entry<T>(&mut self, name: &str)
-    where
-        T: 'static
-    {
-        let mut lookup = self.get_resource_or_default::<TypeLookup>();
-        lookup.typeid_from_name.insert(name.into(), std::any::TypeId::of::<T>());
-    }
 }
 
 impl mlua::FromLua for ScriptBorrow {

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

@@ -1,7 +1,10 @@
-use lyra_ecs::ResourceObject;
-use lyra_reflect::Reflect;
+use std::any::TypeId;
 
-use crate::{lua::{wrappers::*, LuaContext, LuaWrapper, RegisterLuaType, FN_NAME_INTERNAL_REFLECT, FN_NAME_INTERNAL_REFLECT_TYPE}, ScriptApiProvider, ScriptBorrow, ScriptData, ScriptDynamicBundle, ScriptWorldPtr};
+use lyra_ecs::ResourceObject;
+use lyra_reflect::{Reflect, TypeRegistry};
+use lyra_resource::gltf::Gltf;
+
+use crate::{lua::{wrappers::*, LuaContext, LuaWrapper, ReflectLuaProxy, RegisterLuaType, FN_NAME_INTERNAL_REFLECT, FN_NAME_INTERNAL_REFLECT_TYPE}, ScriptApiProvider, ScriptBorrow, ScriptData, ScriptDynamicBundle, ScriptWorldPtr};
 
 //fn register_lua_proxy::<T: 
 
@@ -16,16 +19,24 @@ impl ScriptApiProvider for LyraEcsApiProvider {
         world.register_lua_wrapper::<LuaSceneHandle>();
         world.register_lua_wrapper::<LuaActionHandler>();
         world.register_lua_wrapper::<LuaWindow>();
-        
         world.register_lua_convert_component::<LuaCamera>("Camera");
         world.register_lua_convert_component::<LuaFreeFlyCamera>("FreeFlyCamera");
 
-        world.register_lua_wrapper::<LuaDeviceId>();
-        world.register_lua_convert::<LuaDeviceEventRaw>();
-        world.register_lua_convert::<LuaDeviceEvent>();
-        world.add_lua_event::<LuaDeviceEvent>("DeviceEvent");
+        let mut registry = world.get_resource_mut::<TypeRegistry>().unwrap();
 
-        world.register_asset_handle::<LuaGltfHandle>("Gltf");
+        let reg_type = registry.get_type_or_default(TypeId::of::<Gltf>());
+        reg_type.add_data(ReflectLuaProxy::from_lua_proxy::<LuaGltfHandle>());
+
+        let l = LuaResHandleToComponent::new(
+            |lua, res| {
+                if let Some(gltf) = res.as_typed::<Gltf>() {
+                    Some(lua.create_userdata(LuaGltfHandle(gltf)).unwrap())
+                } else {
+                    None
+                }
+            }
+        );
+        reg_type.add_data(l);
     }
 
     fn expose_api(&mut self, _: &ScriptData, ctx: &mut Self::ScriptContext) -> Result<(), crate::ScriptError> {
@@ -42,9 +53,8 @@ impl ScriptApiProvider for LyraEcsApiProvider {
         globals.set("ActionHandler", ctx.create_proxy::<LuaActionHandler>()?)?;
         globals.set("Window", ctx.create_proxy::<LuaWindow>()?)?;
 
-        expose_comp_table_wrapper::<LuaCamera>(&ctx, &globals, "Camera")?;
-        expose_comp_table_wrapper::<LuaFreeFlyCamera>(&ctx, &globals, "FreeFlyCamera")?;
-        expose_table_wrapper::<LuaDeviceEvent>(&ctx, &globals, "DeviceEvent")?;
+        expose_table_wrapper::<LuaCamera>(&ctx, &globals, "Camera")?;
+        expose_table_wrapper::<LuaFreeFlyCamera>(&ctx, &globals, "FreeFlyCamera")?;
 
         let dt_table = create_reflect_table::<lyra_game::DeltaTime>(&ctx)?;
         globals.set("DeltaTime", dt_table)?;
@@ -94,23 +104,12 @@ where
 /// 
 /// This creates the reflection functions on a table specified in globals.
 /// The table name is set to `name`, which is also how the script will use the table.
-fn expose_comp_table_wrapper<T>(lua: &mlua::Lua, globals: &mlua::Table, name: &str) -> mlua::Result<()>
+fn expose_table_wrapper<T>(lua: &mlua::Lua, globals: &mlua::Table, name: &str) -> mlua::Result<()>
 where 
     T: LuaWrapper + mlua::FromLua,
     T::Wrap: lyra_ecs::Component + Reflect
 {
     let table = create_reflect_comp_table::<T>(&lua, name)?;
     globals.set(name, table)?;
-    Ok(())
-}
-
-fn expose_table_wrapper<T>(lua: &mlua::Lua, globals: &mlua::Table, name: &str) -> mlua::Result<()>
-where 
-    T: LuaWrapper,
-{
-    let table = lua.create_table()?;
-    table.set(mlua::MetaMethod::Type.name(), name.to_string())?;
-    globals.set(name, table)?;
-
     Ok(())
 }

lyra-scripting/src/lua/proxy.rs

@@ -8,8 +8,8 @@ use crate::{ScriptBorrow, ScriptDynamicBundle};
 
 use super::{Error, FN_NAME_INTERNAL_REFLECT};
 
-pub trait LuaWrapper: Sized {
-    type Wrap: 'static;
+pub trait LuaWrapper {
+    type Wrap: Reflect + 'static;
 
     /// The type id of the wrapped type.
     #[inline(always)]
@@ -18,12 +18,6 @@ pub trait LuaWrapper: Sized {
     }
 
     fn into_wrapped(self) -> Self::Wrap;
-    
-    #[inline(always)]
-    fn from_wrapped(wrap: Self::Wrap) -> Option<Self> {
-        let _ = wrap;
-        None
-    }
 }
 
 /// A trait that used to convert something into lua, or to set something to a value from lua.
@@ -42,7 +36,7 @@ pub trait LuaProxy {
 
 impl<'a, T> LuaProxy for T
 where
-    T: Reflect + Clone + mlua::FromLua + mlua::IntoLua
+    T: Reflect + Clone + mlua::FromLua + mlua::UserData
 {
     fn as_lua_value(
         lua: &mlua::Lua,
@@ -53,14 +47,16 @@ where
     }
 
     fn apply(
-        lua: &mlua::Lua,
+        _: &mlua::Lua,
         this: &mut dyn Reflect,
         apply: &mlua::Value,
     ) -> mlua::Result<()> {
         let this = this.as_any_mut().downcast_mut::<T>().unwrap();
-        let apply = T::from_lua(apply.clone(), lua)?;
+        let apply = apply.as_userdata()
+            .expect("Somehow a non-userdata Lua Value was provided to a LuaProxy")
+            .borrow::<T>()?;
 
-        *this = apply;
+        *this = apply.clone();
 
         Ok(())
     }

lyra-scripting/src/lua/world.rs

@@ -10,20 +10,14 @@ use lyra_resource::ResourceManager;
 use mlua::{IntoLua, ObjectLike};
 
 use super::{
-    reflect_user_data,
-    wrappers::{LuaResHandleToComponent, LuaWrappedEventProxy},
-    Error, ReflectLuaProxy, ReflectedIterator, TypeLookup, FN_NAME_INTERNAL_AS_COMPONENT,
-    FN_NAME_INTERNAL_REFLECT, FN_NAME_INTERNAL_REFLECT_TYPE,
+    reflect_user_data, wrappers::LuaResHandleToComponent, Error, TypeLookup, ReflectLuaProxy, ReflectedIterator, FN_NAME_INTERNAL_AS_COMPONENT, FN_NAME_INTERNAL_REFLECT, FN_NAME_INTERNAL_REFLECT_TYPE
 };
 
 impl mlua::FromLua for ScriptEntity {
     fn from_lua(value: mlua::Value, _: &mlua::Lua) -> mlua::Result<Self> {
         match value {
             mlua::Value::UserData(ud) => Ok(ud.borrow::<Self>()?.clone()),
-            mlua::Value::Nil => Err(mlua::Error::external(Error::type_mismatch(
-                "ScriptEntity",
-                "Nil",
-            ))),
+            mlua::Value::Nil => Err(mlua::Error::external(Error::type_mismatch("ScriptEntity", "Nil"))),
             _ => panic!(),
         }
     }
@@ -47,10 +41,7 @@ impl mlua::FromLua for ScriptWorldPtr {
     fn from_lua(val: mlua::Value, _: &mlua::Lua) -> mlua::Result<Self> {
         match val {
             mlua::Value::UserData(ud) => Ok(ud.borrow::<Self>()?.clone()),
-            mlua::Value::Nil => Err(mlua::Error::external(Error::type_mismatch(
-                "ScriptWorldPtr",
-                "Nil",
-            ))),
+            mlua::Value::Nil => Err(mlua::Error::external(Error::type_mismatch("ScriptWorldPtr", "Nil"))),
             _ => panic!(),
         }
     }
@@ -73,7 +64,8 @@ impl mlua::UserData for ScriptWorldPtr {
                 })?;
 
                 let comp_borrow = {
-                    if let Ok(as_comp) = ud.get::<mlua::Function>(FN_NAME_INTERNAL_AS_COMPONENT) {
+                    if let Ok(as_comp) = ud.get::<mlua::Function>(FN_NAME_INTERNAL_AS_COMPONENT)
+                    {
                         let ud = match as_comp.call(ud.clone())? {
                             mlua::Value::UserData(ud) => ud,
                             mlua::Value::Nil => ud.clone(),
@@ -123,12 +115,11 @@ impl mlua::UserData for ScriptWorldPtr {
                         mlua::Value::Table(t) => {
                             let name: String = t.get(mlua::MetaMethod::Type.name())?;
 
-                            let lookup =
-                                world
-                                    .get_resource::<TypeLookup>()
-                                    .ok_or(mlua::Error::runtime(
-                                        "Unable to lookup table proxy, none were ever registered!",
-                                    ))?;
+                            let lookup = world.get_resource::<TypeLookup>().ok_or(
+                                mlua::Error::runtime(
+                                    "Unable to lookup table proxy, none were ever registered!",
+                                ),
+                            )?;
                             let info = lookup.comp_info_from_name.get(&name).ok_or_else(|| {
                                 mlua::Error::BadArgument {
                                     to: Some("World:view".into()),
@@ -148,7 +139,10 @@ impl mlua::UserData for ScriptWorldPtr {
                         }
                         mlua::Value::UserData(ud) => {
                             let reflect = ud
-                                .call_function::<ScriptBorrow>(FN_NAME_INTERNAL_REFLECT_TYPE, ())
+                                .call_function::<ScriptBorrow>(
+                                    FN_NAME_INTERNAL_REFLECT_TYPE,
+                                    (),
+                                )
                                 .expect("Type does not implement 'reflect_type' properly");
                             let refl_comp = reflect.reflect_branch.as_component_unchecked();
 
@@ -178,9 +172,7 @@ impl mlua::UserData for ScriptWorldPtr {
                 let mut world = this.write();
 
                 while let Some(row) = reflected_iter.next_lua(lua) {
-                    let r = row
-                        .row
-                        .into_iter()
+                    let r = row.row.into_iter()
                         .into_iter()
                         .map(|r| (r.comp_val, r.comp_ptr.cast::<()>()))
                         .collect::<Vec<_>>();
@@ -191,6 +183,7 @@ impl mlua::UserData for ScriptWorldPtr {
 
                     // if values were returned, find the type in the type registry, and apply the new values
                     if res.len() <= ptrs.len() {
+
                         for (comp, ptr) in res.into_iter().zip(ptrs) {
                             let lua_typeid = match &comp {
                                 mlua::Value::UserData(ud) => {
@@ -317,41 +310,5 @@ impl mlua::UserData for ScriptWorldPtr {
 
             Ok((data.fn_to_lua)(lua, handle).unwrap())
         });
-        methods.add_method_mut(
-            "read_event",
-            |lua, this, either: mlua::Either<String, mlua::Table>| {
-                let mut world = this.write();
-
-                // get the type name
-                let name = match either {
-                    mlua::Either::Left(name) => name,
-                    mlua::Either::Right(table) => table.get(mlua::MetaMethod::Type.name())?,
-                };
-
-                // lookup the type id using the name, return an error if not found
-                let lookup = world.get_resource::<TypeLookup>().unwrap();
-                let tyid = lookup.typeid_from_name.get(&name).cloned();
-                if tyid.is_none() {
-                    return Err(mlua::Error::runtime(format!(
-                        "failed to lookup type id from type name: {}",
-                        name
-                    )));
-                }
-                let tyid = tyid.unwrap();
-                drop(lookup);
-
-                let registry = world.get_resource::<TypeRegistry>().unwrap();
-                let ty = registry
-                    .get_type(tyid)
-                    .expect("Could not find asset type in registry");
-                let data = ty
-                    .get_data::<LuaWrappedEventProxy>()
-                    .expect("Asset type does not have 'LuaWrappedEventProxy' as TypeData")
-                    .clone();
-                drop(registry);
-
-                data.reader(&mut world).into_lua(lua)
-            },
-        );
     }
 }

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

@@ -1,237 +0,0 @@
-use std::{any::TypeId, ops::Deref};
-use lyra_resource::{gltf::{Gltf, Material, Mesh}, FilterMode, ResHandle, Texture, WrappingMode};
-use lyra_game::scene::SceneGraph;
-use lyra_reflect::Reflect;
-use lyra_scripting_derive::{lua_wrap_handle, wrap_lua_struct};
-
-use crate::{lua::{LuaWrapper, FN_NAME_INTERNAL_REFLECT, FN_NAME_INTERNAL_REFLECT_TYPE}, lyra_engine, ScriptBorrow};
-use crate as lyra_scripting;
-
-use super::LuaHandleWrapper;
-
-use mlua::IntoLua;
-
-fn filter_mode_to_str(fm: FilterMode) -> &'static str {
-    match fm {
-        FilterMode::Nearest => "nearest",
-        FilterMode::Linear => "linear",
-    }
-}
-
-fn wrapping_mode_to_str(wm: WrappingMode) -> &'static str {
-    match wm {
-        WrappingMode::ClampToEdge => "clamp_to_edge",
-        WrappingMode::MirroredRepeat => "mirrored_repeat",
-        WrappingMode::Repeat => "repeat",
-    }
-}
-
-wrap_lua_struct!(lyra_resource::TextureSampler,
-    // this can be safely skipped since it wont be a component or resource.
-    skip(lua_reflect),
-    fields={
-        // don't need to specify field types since setters are skipped
-        (mag_filter, skip_set, get={
-            this.mag_filter.map(|f| filter_mode_to_str(f))
-                .into_lua(lua)
-        }),
-        (min_filter, skip_set, get={
-            this.min_filter.map(|f| filter_mode_to_str(f))
-                .into_lua(lua)
-        }),
-        (mipmap_filter, skip_set, get={
-            this.mipmap_filter.map(|f| filter_mode_to_str(f))
-                .into_lua(lua)
-        }),
-        (wrap_u, skip_set, get={
-            wrapping_mode_to_str(this.wrap_u)
-                .into_lua(lua)
-        }),
-        (wrap_v, skip_set, get={
-            wrapping_mode_to_str(this.wrap_v)
-                .into_lua(lua)
-        }),
-        (wrap_w, skip_set, get={
-            wrapping_mode_to_str(this.wrap_w)
-                .into_lua(lua)
-        }),
-    }
-);
-
-wrap_lua_struct!(lyra_resource::gltf::PbrGlossiness,
-    // this can be safely skipped since it wont be a component or resource.
-    skip(lua_reflect),
-    fields={
-        (diffuse_color: wrap(crate::lua::wrappers::LuaVec4), skip_set),
-        (specular: wrap(crate::lua::wrappers::LuaVec3), skip_set),
-        (glossiness, skip_set),
-    }
-);
-
-wrap_lua_struct!(lyra_resource::gltf::Specular,
-    // this can be safely skipped since it wont be a component or resource.
-    skip(lua_reflect),
-    fields={
-        (factor, skip_set),
-        (color_factor: wrap(crate::lua::wrappers::LuaVec3), skip_set),
-        (texture, skip_set, get={
-            this.texture.clone()
-                .map(|t| LuaTextureHandle(t))
-                .into_lua(lua)
-        }),
-        (color_texture, skip_set, get={
-            this.color_texture.clone()
-                .map(|t| LuaTextureHandle(t))
-                .into_lua(lua)
-        })
-    }
-);
-
-// TODO: fields
-lua_wrap_handle!(SceneGraph, name=Scene, {});
-
-lua_wrap_handle!(Mesh,
-    field_getters={
-        (material, {
-            data.material.clone()
-                .map(|v| LuaMaterialHandle(v.clone()))
-                .into_lua(lua)
-        })
-    },
-    {
-        methods.add_method("indices", |lua, this, ()| {
-            if let Some(data) = this.0.data_ref() {
-                let table = lua.create_table()?;
-    
-                match &data.indices {
-                    Some(lyra_resource::gltf::MeshIndices::U16(v)) => {
-                        for (i, ind) in v.iter().enumerate() {
-                            let i = i as i64 + 1; // lua indexes start at 1
-                            table.raw_set(i, *ind)?;
-                        }
-                    },
-                    Some(lyra_resource::gltf::MeshIndices::U32(v)) => {
-                        for (i, ind) in v.iter().enumerate() {
-                            let i = i as i64 + 1; // lua indexes start at 1
-                            table.raw_set(i, *ind)?;
-                        }
-                    },
-                    None => {},
-                }
-    
-                Ok(mlua::Value::Table(table))
-            } else {
-                Ok(mlua::Value::Nil)
-            }
-        });
-
-        // TODO: mesh attributes
-    }
-);
-
-lua_wrap_handle!(lyra_resource::Image,
-    field_getters={
-        (width, {
-            data.width().into_lua(lua)
-        }),
-        (height, {
-            data.height().into_lua(lua)
-        })
-    }
-);
-
-lua_wrap_handle!(Texture,
-    field_getters={
-        (image, wrapper=LuaImageHandle),
-        (sampler, {
-            data.sampler.clone()
-                .map(|s| LuaTextureSampler(s))
-                .into_lua(lua)
-        })
-    }
-
-);
-
-lua_wrap_handle!(Material,
-    field_getters={
-        shader_uuid,
-        name,
-        double_sided,
-        (base_color, wrapper=crate::lua::wrappers::LuaVec4),
-        metallic,
-        roughness,
-        (base_color_texture, {
-            data.base_color_texture.clone()
-                .map(|v| LuaTextureHandle(v.clone()))
-                .into_lua(lua)
-        }),
-        (metallic_roughness_texture, {
-            data.metallic_roughness_texture.clone()
-                .map(|v| LuaTextureHandle(v.clone()))
-                .into_lua(lua)
-        }),
-        (pbr_glossiness, {
-            data.pbr_glossiness.clone()
-                .map(|v| LuaPbrGlossiness(v.clone()))
-                .into_lua(lua)
-        }),
-        alpha_cutoff,
-        (alpha_mode, {
-            match data.alpha_mode {
-                lyra_resource::gltf::AlphaMode::Opaque => "opaque",
-                lyra_resource::gltf::AlphaMode::Mask => "mask",
-                lyra_resource::gltf::AlphaMode::Blend => "blend",
-            }.into_lua(lua)
-        }),
-        (specular, {
-            data.specular.clone()
-                .map(|v| LuaSpecular(v.clone()))
-                .into_lua(lua)
-        }),
-    }
-);
-
-lua_wrap_handle!(Gltf, {
-    methods.add_method("scenes", |lua, this, ()| {
-        if let Some(data) = this.0.data_ref() {
-            let table = lua.create_table()?;
-
-            for (i, scene) in data.scenes.iter().enumerate() {
-                let i = i as i64 + 1; // lua indexes start at 1
-                table.raw_set(i, LuaSceneHandle(scene.clone()))?;
-            }
-
-            Ok(mlua::Value::Table(table))
-        } else {
-            Ok(mlua::Value::Nil)
-        }
-    });
-    methods.add_method("materials", |lua, this, ()| {
-        if let Some(data) = this.0.data_ref() {
-            let table = lua.create_table()?;
-
-            for (i, mat) in data.materials.iter().enumerate() {
-                let i = i as i64 + 1; // lua indexes start at 1
-                table.raw_set(i, LuaMaterialHandle(mat.clone()))?;
-            }
-
-            Ok(mlua::Value::Table(table))
-        } else {
-            Ok(mlua::Value::Nil)
-        }
-    });
-    methods.add_method("meshes", |lua, this, ()| {
-        if let Some(data) = this.0.data_ref() {
-            let table = lua.create_table()?;
-
-            for (i, mesh) in data.meshes.iter().enumerate() {
-                let i = i as i64 + 1; // lua indexes start at 1
-                table.raw_set(i, LuaMeshHandle(mesh.clone()))?;
-            }
-
-            Ok(mlua::Value::Table(table))
-        } else {
-            Ok(mlua::Value::Nil)
-        }
-    });
-});

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

@@ -1,37 +1,21 @@
-use lyra_resource::{ResHandle, ResourceData, UntypedResHandle};
-use lyra_reflect::FromType;
-use crate::lua::LuaWrapper;
+use std::{any::TypeId, ops::Deref};
+//use mlua::{AnyUserData, IntoLua, FromLua, Lua, Value};
+use lyra_resource::{gltf::{Gltf, Material, Mesh}, FilterMode, ResHandle, Texture, UntypedResHandle, WrappingMode};
+use lyra_game::scene::SceneGraph;
+use lyra_reflect::{Reflect, TypeData};
+use lyra_scripting_derive::{lua_wrap_handle, wrap_lua_struct};
 
-mod gltf;
-pub use gltf::*;
+use crate::{lua::{Error, LuaWrapper, FN_NAME_INTERNAL_AS_COMPONENT, FN_NAME_INTERNAL_REFLECT, FN_NAME_INTERNAL_REFLECT_TYPE}, lyra_engine, ScriptBorrow};
 
-pub trait LuaHandleWrapper: LuaWrapper + mlua::UserData + Send + 'static {
-    type ResourceType: lyra_resource::ResourceData;
+use crate as lyra_scripting;
 
-    fn from_handle(handle: ResHandle<Self::ResourceType>) -> Self;
-}
+use mlua::IntoLua;
 
-#[derive(Clone)]
 pub struct LuaResHandleToComponent {
     /// Create the userdata component that 
     pub fn_to_lua: fn(&mlua::Lua, UntypedResHandle) -> Option<mlua::AnyUserData>,
 }
 
-impl<T> FromType<T> for LuaResHandleToComponent
-where 
-    T: LuaHandleWrapper,
-    T::ResourceType: ResourceData,
-{
-    fn from_type() -> Self {
-        Self {
-            fn_to_lua: |lua: &mlua::Lua, handle: UntypedResHandle| {
-                handle.as_typed::<T::ResourceType>()
-                    .map(|res| lua.create_userdata(T::from_handle(res)).unwrap())
-            },
-        }
-    }
-}
-
 impl LuaResHandleToComponent {
     pub fn new(f: fn(&mlua::Lua, UntypedResHandle) -> Option<mlua::AnyUserData>) -> Self {
         Self {
@@ -39,3 +23,315 @@ impl LuaResHandleToComponent {
         }
     }
 }
+
+impl TypeData for LuaResHandleToComponent {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+
+    fn boxed_clone(&self) -> Box<dyn TypeData> {
+        todo!()
+    }
+}
+
+#[derive(Clone)]
+pub struct LuaResHandle(pub UntypedResHandle);
+
+impl Deref for LuaResHandle {
+    type Target = UntypedResHandle;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<UntypedResHandle> for LuaResHandle {
+    fn from(value: UntypedResHandle) -> Self {
+        LuaResHandle(value)
+    }
+}
+
+impl mlua::UserData for LuaResHandle {
+    fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
+        fields.add_field_method_get("path", |_, this| Ok(this.path()));
+        fields.add_field_method_get("version", |_, this| Ok(this.version()));
+        fields.add_field_method_get("uuid", |_, this| Ok(this.uuid().to_string()));
+        fields.add_field_method_get("state", |_, this| {
+            let name = if this.is_loaded() {
+                "ready"
+            } else if this.get_error().is_some() {
+                "error"
+            } else { "loading" };
+
+            Ok(name)
+        });
+    }    
+
+    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
+        methods.add_method("is_watched", |_, this, ()| {
+            Ok(this.is_watched())
+        });
+        
+        methods.add_method("is_loaded", |_, this, ()| {
+            Ok(this.is_loaded())
+        });
+        
+        methods.add_method("wait_until_loaded", |_, this, ()| {
+            this.wait_recurse_dependencies_load();
+
+            Ok(())
+        });
+
+        methods.add_method(FN_NAME_INTERNAL_AS_COMPONENT, |lua, this, ()| {
+            let handle = &this.0;
+
+            if let Some(handle) = handle.as_typed::<SceneGraph>() {
+                LuaSceneHandle(handle).into_lua(lua)
+            } else if let Some(handle) = handle.as_typed::<Gltf>() {
+                LuaGltfHandle(handle).into_lua(lua)
+            } else {
+                Ok(mlua::Value::Nil)
+            }
+        });
+    }
+}
+
+impl mlua::FromLua for LuaResHandle {
+    fn from_lua(val: mlua::Value, _: &mlua::Lua) -> mlua::Result<Self> {
+        let tyname = val.type_name();
+        let ud = val.as_userdata()
+            .ok_or(mlua::Error::external(Error::type_mismatch("Handle", &tyname)))?;
+        let handle = ud.borrow::<LuaResHandle>()?;
+        
+        Ok(handle.clone())
+    }
+}
+
+fn filter_mode_to_str(fm: FilterMode) -> &'static str {
+    match fm {
+        FilterMode::Nearest => "nearest",
+        FilterMode::Linear => "linear",
+    }
+}
+
+fn wrapping_mode_to_str(wm: WrappingMode) -> &'static str {
+    match wm {
+        WrappingMode::ClampToEdge => "clamp_to_edge",
+        WrappingMode::MirroredRepeat => "mirrored_repeat",
+        WrappingMode::Repeat => "repeat",
+    }
+}
+
+wrap_lua_struct!(lyra_resource::TextureSampler,
+    // this can be safely skipped since it wont be a component or resource.
+    skip(lua_reflect),
+    fields={
+        // don't need to specify field types since setters are skipped
+        (mag_filter, skip_set, get={
+            this.mag_filter.map(|f| filter_mode_to_str(f))
+                .into_lua(lua)
+        }),
+        (min_filter, skip_set, get={
+            this.min_filter.map(|f| filter_mode_to_str(f))
+                .into_lua(lua)
+        }),
+        (mipmap_filter, skip_set, get={
+            this.mipmap_filter.map(|f| filter_mode_to_str(f))
+                .into_lua(lua)
+        }),
+        (wrap_u, skip_set, get={
+            wrapping_mode_to_str(this.wrap_u)
+                .into_lua(lua)
+        }),
+        (wrap_v, skip_set, get={
+            wrapping_mode_to_str(this.wrap_v)
+                .into_lua(lua)
+        }),
+        (wrap_w, skip_set, get={
+            wrapping_mode_to_str(this.wrap_w)
+                .into_lua(lua)
+        }),
+    }
+);
+
+wrap_lua_struct!(lyra_resource::gltf::PbrGlossiness,
+    // this can be safely skipped since it wont be a component or resource.
+    skip(lua_reflect),
+    fields={
+        (diffuse_color: wrap(crate::lua::wrappers::LuaVec4), skip_set),
+        (specular: wrap(crate::lua::wrappers::LuaVec3), skip_set),
+        (glossiness, skip_set),
+    }
+);
+
+wrap_lua_struct!(lyra_resource::gltf::Specular,
+    // this can be safely skipped since it wont be a component or resource.
+    skip(lua_reflect),
+    fields={
+        (factor, skip_set),
+        (color_factor: wrap(crate::lua::wrappers::LuaVec3), skip_set),
+        (texture, skip_set, get={
+            this.texture.clone()
+                .map(|t| LuaTextureHandle(t))
+                .into_lua(lua)
+        }),
+        (color_texture, skip_set, get={
+            this.color_texture.clone()
+                .map(|t| LuaTextureHandle(t))
+                .into_lua(lua)
+        })
+    }
+);
+
+// TODO: fields
+lua_wrap_handle!(SceneGraph, name=Scene, {});
+
+lua_wrap_handle!(Mesh,
+    field_getters={
+        (material, {
+            data.material.clone()
+                .map(|v| LuaMaterialHandle(v.clone()))
+                .into_lua(lua)
+        })
+    },
+    {
+        methods.add_method("indices", |lua, this, ()| {
+            if let Some(data) = this.0.data_ref() {
+                let table = lua.create_table()?;
+    
+                match &data.indices {
+                    Some(lyra_resource::gltf::MeshIndices::U16(v)) => {
+                        for (i, ind) in v.iter().enumerate() {
+                            let i = i as i64 + 1; // lua indexes start at 1
+                            table.raw_set(i, *ind)?;
+                        }
+                    },
+                    Some(lyra_resource::gltf::MeshIndices::U32(v)) => {
+                        for (i, ind) in v.iter().enumerate() {
+                            let i = i as i64 + 1; // lua indexes start at 1
+                            table.raw_set(i, *ind)?;
+                        }
+                    },
+                    None => {},
+                }
+    
+                Ok(mlua::Value::Table(table))
+            } else {
+                Ok(mlua::Value::Nil)
+            }
+        });
+
+        // TODO: mesh attributes
+    }
+);
+
+lua_wrap_handle!(lyra_resource::Image,
+    field_getters={
+        (width, {
+            data.width().into_lua(lua)
+        }),
+        (height, {
+            data.height().into_lua(lua)
+        })
+    }
+);
+
+lua_wrap_handle!(Texture,
+    field_getters={
+        (image, wrapper=LuaImageHandle),
+        (sampler, {
+            data.sampler.clone()
+                .map(|s| LuaTextureSampler(s))
+                .into_lua(lua)
+        })
+    }
+
+);
+
+lua_wrap_handle!(Material,
+    field_getters={
+        shader_uuid,
+        name,
+        double_sided,
+        (base_color, wrapper=crate::lua::wrappers::LuaVec4),
+        metallic,
+        roughness,
+        (base_color_texture, {
+            data.base_color_texture.clone()
+                .map(|v| LuaTextureHandle(v.clone()))
+                .into_lua(lua)
+        }),
+        (metallic_roughness_texture, {
+            data.metallic_roughness_texture.clone()
+                .map(|v| LuaTextureHandle(v.clone()))
+                .into_lua(lua)
+        }),
+        (pbr_glossiness, {
+            data.pbr_glossiness.clone()
+                .map(|v| LuaPbrGlossiness(v.clone()))
+                .into_lua(lua)
+        }),
+        alpha_cutoff,
+        (alpha_mode, {
+            match data.alpha_mode {
+                lyra_resource::gltf::AlphaMode::Opaque => "opaque",
+                lyra_resource::gltf::AlphaMode::Mask => "mask",
+                lyra_resource::gltf::AlphaMode::Blend => "blend",
+            }.into_lua(lua)
+        }),
+        (specular, {
+            data.specular.clone()
+                .map(|v| LuaSpecular(v.clone()))
+                .into_lua(lua)
+        }),
+    }
+);
+
+lua_wrap_handle!(Gltf, {
+    methods.add_method("scenes", |lua, this, ()| {
+        if let Some(data) = this.0.data_ref() {
+            let table = lua.create_table()?;
+
+            for (i, scene) in data.scenes.iter().enumerate() {
+                let i = i as i64 + 1; // lua indexes start at 1
+                table.raw_set(i, LuaSceneHandle(scene.clone()))?;
+            }
+
+            Ok(mlua::Value::Table(table))
+        } else {
+            Ok(mlua::Value::Nil)
+        }
+    });
+    methods.add_method("materials", |lua, this, ()| {
+        if let Some(data) = this.0.data_ref() {
+            let table = lua.create_table()?;
+
+            for (i, mat) in data.materials.iter().enumerate() {
+                let i = i as i64 + 1; // lua indexes start at 1
+                table.raw_set(i, LuaMaterialHandle(mat.clone()))?;
+            }
+
+            Ok(mlua::Value::Table(table))
+        } else {
+            Ok(mlua::Value::Nil)
+        }
+    });
+    methods.add_method("meshes", |lua, this, ()| {
+        if let Some(data) = this.0.data_ref() {
+            let table = lua.create_table()?;
+
+            for (i, mesh) in data.meshes.iter().enumerate() {
+                let i = i as i64 + 1; // lua indexes start at 1
+                table.raw_set(i, LuaMeshHandle(mesh.clone()))?;
+            }
+
+            Ok(mlua::Value::Table(table))
+        } else {
+            Ok(mlua::Value::Nil)
+        }
+    });
+});

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

@@ -4,18 +4,16 @@ use lyra_game::{
     math::Vec2,
     winit::{
         dpi::PhysicalPosition, DeviceEvent, DeviceEventPair, DeviceId, MouseScrollDelta,
-        PhysicalKey, RawKeyEvent,
+        PhysicalKey,
     },
 };
-use lyra_reflect::Reflect;
 use lyra_scripting_derive::wrap_lua_struct;
 
-use crate as lyra_scripting;
 use crate::lyra_engine;
 
 use super::LuaVec2;
 
-wrap_lua_struct!(DeviceId, skip(lua_reflect));
+wrap_lua_struct!(DeviceId, skip(lua_reflect, lua_wrapper));
 
 /// Wraps [`DeviceEvent`] and implements [`IntoLua`]
 #[derive(Clone)]
@@ -44,7 +42,7 @@ impl mlua::FromLua for LuaDeviceEventRaw {
             message: Some("expected Lua Table".into()),
         })?;
 
-        let type_str: String = table.get("kind")?;
+        let type_str: String = table.get("type")?;
         let type_str = type_str.as_str();
 
         let ret = match type_str {
@@ -127,9 +125,8 @@ impl mlua::FromLua for LuaDeviceEventRaw {
                             message: Some(format!("unknown key code: '{}'", code_str)),
                         });
                     }
-                    let code = code.unwrap();
 
-                    let phy = PhysicalKey::Code(code.as_winit_keycode().unwrap());
+                    let phy = PhysicalKey::Code(code);
                     Self(DeviceEvent::Key(RawKeyEvent {
                         physical_key: phy,
                         state,
@@ -143,19 +140,12 @@ impl mlua::FromLua for LuaDeviceEventRaw {
                         "unknown" => NativeKeyCode::Unidentified,
                         "android" => NativeKeyCode::Android(native_code),
                         "macos" => NativeKeyCode::MacOS(native_code as u16),
-                        "windows" => NativeKeyCode::Windows(native_code as u16),
+                        "windows" => NativeKeyCode::Windows(native_code),
                         "xkb" => NativeKeyCode::Xkb(native_code),
-                        _ => {
-                            return Err(mlua::Error::FromLuaConversionError {
-                                from: ty,
-                                to: "LuaDeviceEventRaw".into(),
-                                message: Some(format!("unknown native code type: {}", native_str)),
-                            });
-                        }
                     };
 
                     Self(DeviceEvent::Key(RawKeyEvent {
-                        physical_key: PhysicalKey::Unidentified(native_code.into()),
+                        physical_key: PhysicalKey::Unidentified(native_code),
                         state,
                     }))
                 } else {
@@ -189,17 +179,17 @@ impl mlua::IntoLua for LuaDeviceEventRaw {
 
         match self.0 {
             DeviceEvent::Added => {
-                table.set("kind", "added")?;
+                table.set("type", "added")?;
             }
             DeviceEvent::Removed => {
-                table.set("kind", "removed")?;
+                table.set("type", "removed")?;
             }
             DeviceEvent::MouseMotion { delta } => {
-                table.set("kind", "mouse_motion")?;
+                table.set("type", "mouse_motion")?;
                 table.set("delta", LuaVec2(Vec2::new(delta.0 as _, delta.1 as _)))?;
             }
             DeviceEvent::MouseWheel { delta } => {
-                table.set("kind", "mouse_wheel")?;
+                table.set("type", "mouse_wheel")?;
 
                 match delta {
                     MouseScrollDelta::LineDelta(x, y) => {
@@ -214,12 +204,12 @@ impl mlua::IntoLua for LuaDeviceEventRaw {
                 }
             }
             DeviceEvent::Motion { axis, value } => {
-                table.set("kind", "motion")?;
+                table.set("type", "motion")?;
                 table.set("axis", axis)?;
                 table.set("value", value)?;
             }
             DeviceEvent::Button { button, state } => {
-                table.set("kind", "button")?;
+                table.set("type", "button")?;
                 table.set("button", button)?;
 
                 let state = match state {
@@ -229,7 +219,7 @@ impl mlua::IntoLua for LuaDeviceEventRaw {
                 table.set("state", state)?;
             }
             DeviceEvent::Key(raw_key_event) => {
-                table.set("kind", "key")?;
+                table.set("type", "key")?;
 
                 let state = match raw_key_event.state {
                     lyra_game::winit::ElementState::Pressed => "pressed",
@@ -272,16 +262,7 @@ impl mlua::IntoLua for LuaDeviceEventRaw {
     }
 }
 
-impl LuaWrapper for LuaDeviceEventRaw {
-    type Wrap = DeviceEvent;
-
-    #[inline(always)]
-    fn into_wrapped(self) -> Self::Wrap {
-        self.0
-    }
-}
-
-#[derive(Clone, Reflect)]
+#[derive(Clone)]
 pub struct LuaDeviceEvent(pub(crate) DeviceEventPair);
 
 impl std::ops::Deref for LuaDeviceEvent {
@@ -311,8 +292,8 @@ impl mlua::FromLua for LuaDeviceEvent {
         let ev: LuaDeviceEventRaw = table.get("event")?;
 
         Ok(Self(DeviceEventPair {
-            device_src: id.0,
-            event: ev.0,
+            device_src: id,
+            event: ev,
         }))
     }
 }
@@ -322,6 +303,7 @@ impl mlua::IntoLua for LuaDeviceEvent {
         let table = lua.create_table()?;
         table.set("device", LuaDeviceId(self.device_src))?;
         table.set("event", LuaDeviceEventRaw(self.event.clone()))?;
+
         table.into_lua(lua)
     }
 }
@@ -333,9 +315,4 @@ impl LuaWrapper for LuaDeviceEvent {
     fn into_wrapped(self) -> Self::Wrap {
         self.0
     }
-
-    #[inline(always)]
-    fn from_wrapped(wrap: Self::Wrap) -> Option<Self> {
-        Some(Self(wrap))
-    }
-}
+}

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

@@ -1,151 +0,0 @@
-use std::{marker::PhantomData, sync::Arc};
-
-use crate::lua::LuaWrapper;
-use atomic_refcell::AtomicRefCell;
-use lyra_ecs::World;
-use lyra_game::{
-    Event, EventReader, EventWriter, Events,
-};
-use lyra_reflect::{FromType, Reflect};
-use mlua::{FromLua, IntoLua};
-
-use super::LuaVec2;
-
-mod device_event;
-pub use device_event::*;
-
-/// Helper trait to type erase EventReader<T>
-trait UntypedEventReader: Send + Sync {
-    fn next(&self, lua: &mlua::Lua) -> mlua::Result<mlua::Value>;
-}
-
-/// Helper trait to type erase EventWriter<T>
-trait UntypedEventWriter: Send + Sync {
-    fn push(&self, lua: &mlua::Lua, event: mlua::Value) -> mlua::Result<()>;
-}
-
-/// Event reader exposed to Lua
-#[derive(Clone)]
-pub struct LuaEventReader(Arc<AtomicRefCell<dyn UntypedEventReader>>);
-
-impl mlua::FromLua for LuaEventReader {
-    fn from_lua(value: mlua::Value, _: &mlua::Lua) -> mlua::Result<Self> {
-        let ty = value.type_name();
-        let ud = value.as_userdata()
-            .ok_or(mlua::Error::FromLuaConversionError { from: ty, to: "EventReader".into(), message: None })?;
-        let reader = ud.borrow::<Self>()?;
-        Ok(reader.clone())
-    }
-}
-
-impl mlua::UserData for LuaEventReader {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
-        methods.add_method("read", |lua, this, ()| {
-            let reg = lua.create_registry_value(this.clone())?;
-            
-            lua.create_function(move |lua: &mlua::Lua, ()| {
-                let reader = lua.registry_value::<Self>(&reg)?;
-                let reader = reader.0.borrow();
-                reader.next(lua)
-            })
-        });
-    }
-}
-
-/// Event writer exposed to Lua
-#[derive(Clone)]
-pub struct LuaEventWriter(Arc<AtomicRefCell<dyn UntypedEventWriter>>);
-
-impl mlua::UserData for LuaEventWriter {
-    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
-        methods.add_method("write", |lua, this, event: mlua::Value| {
-            let writer = this.0.borrow();
-            writer.push(lua, event)?;
-            Ok(())
-        });
-    }
-}
-
-struct TypedReader<T>
-where
-    T: Reflect + LuaWrapper + IntoLua + Send + Sync,
-    T::Wrap: Clone + Event,
-{
-    reader: EventReader<T::Wrap>,
-    _marker: PhantomData<T>,
-}
-
-impl<T> UntypedEventReader for TypedReader<T>
-where
-    T: Reflect + LuaWrapper + IntoLua + Send + Sync,
-    T::Wrap: Clone + Event,
-{
-    fn next(&self, lua: &mlua::Lua) -> mlua::Result<mlua::Value> {
-        self.reader
-            .read()
-            .map(|e| T::from_wrapped(e.clone()).into_lua(lua))
-            .unwrap_or(Ok(mlua::Value::Nil))
-    }
-}
-
-struct TypedWriter<T>
-where
-    T: Reflect + LuaWrapper + FromLua,
-    T::Wrap: Clone + Event,
-{
-    writer: EventWriter<T::Wrap>,
-    _marker: PhantomData<T>,
-}
-
-impl<T> UntypedEventWriter for TypedWriter<T>
-where
-    T: Reflect + LuaWrapper + FromLua,
-    T::Wrap: Clone + Event,
-{
-    fn push(&self, lua: &mlua::Lua, event: mlua::Value) -> mlua::Result<()> {
-        let ev = T::from_lua(event, lua)?.into_wrapped();
-        self.writer.write(ev);
-        Ok(())
-    }
-}
-
-#[derive(Clone)]
-pub struct LuaWrappedEventProxy {
-    fn_reader: for<'a> fn(world: &'a mut World) -> Arc<AtomicRefCell<dyn UntypedEventReader>>,
-    fn_writer: for<'a> fn(world: &'a mut World) -> Arc<AtomicRefCell<dyn UntypedEventWriter>>,
-}
-
-impl<T> FromType<T> for LuaWrappedEventProxy
-where 
-    T: Reflect + LuaWrapper + FromLua + IntoLua + Send + Sync,
-    T::Wrap: Clone + Event,
-{
-    fn from_type() -> Self {
-        Self {
-            fn_reader: |world| {
-                let events = world.get_resource_or_default::<Events<T::Wrap>>();
-                Arc::new(AtomicRefCell::new(TypedReader {
-                    reader: events.reader(),
-                    _marker: PhantomData::<T>,
-                }))
-            },
-            fn_writer: |world| {
-                let events = world.get_resource_or_default::<Events<T::Wrap>>();
-                Arc::new(AtomicRefCell::new(TypedWriter {
-                    writer: events.writer(),
-                    _marker: PhantomData::<T>,
-                }))
-            },
-        }
-    }
-}
-
-impl LuaWrappedEventProxy {
-    pub fn reader(&self, world: &mut World) -> LuaEventReader {
-        LuaEventReader((self.fn_reader)(world))
-    }
-
-    pub fn writer(&self, world: &mut World) -> LuaEventWriter {
-        LuaEventWriter((self.fn_writer)(world))
-    }
-}

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

@@ -1,4 +1,4 @@
-use lyra_game::input::{Action, ActionHandler, ActionKind, ActionMapping, ActionMappingId, ActionSource, ActionState, KeyCode, LayoutId, MouseAxis, MouseInput};
+use lyra_game::input::{keycode_from_str, Action, ActionHandler, ActionKind, ActionMapping, ActionMappingId, ActionSource, ActionState, LayoutId, MouseAxis, MouseInput};
 use mlua::IntoLua;
 use crate::{lua::Error, lyra_engine};
 
@@ -185,7 +185,7 @@ impl LuaWrapper for LuaActionHandler {
 }
 
 fn process_keyboard_string(key_name: &str) -> Option<ActionSource> {
-    let key = KeyCode::from_str(key_name)?;
+    let key = keycode_from_str(key_name)?;
     
     Some(ActionSource::Keyboard(key))
 }