register vec lua types FOR ALL THE TYPES BABY

Author: makspll

assets/scripts/bevy_api.lua

@@ -25,8 +25,8 @@ function on_event()
     print(comp.option_usize)
     comp.option_usize = nil
     print(comp.option_usize)
-    world:exit()
 
+    print("vec")
     print(comp.vec_of_usize)
     print(comp.vec_of_usize[2])
     comp.vec_of_usize[2] = 69
@@ -35,16 +35,6 @@ function on_event()
 
     print("============")
 
-    -- the index metamethod on ReflectValue's uses bevy's reflection mechanism on top of some custom sub-reflection logic to
-    -- allow reflecting inside Options, Vectors etc. 
-    -- when we index into ReflectValue's we either get back a custom proxy or another ReflectValue
-
-    -- the LuaBevyAPIProvider provides us custom proxies for many bevy types as well as std types.
-    -- all of these implementations can be overridden via the bevy TypeRegistry
-    print("Hello:", comp.usize._1)
-    comp.usize[1] = 2
-    print("comp.usize after assigning to 2: ", comp.usize._1)
-
     -- vec's and matrices have custom __index and __newindex overrides
     print("comp.vec2 before: ", comp.vec2)
     comp.vec2[1] = 69

crates/bevy_mod_scripting_core/src/reflection_extensions.rs

@@ -14,6 +14,9 @@ pub trait PartialReflectExt {
     /// If the type is an option, returns either the inner value or None if the option is None.
     /// Errors if the type is not an option.
     fn as_option(&self) -> Result<Option<&dyn PartialReflect>, ScriptError>;
+
+    /// If the type is an iterable list-like type, returns an iterator over the elements.
+    fn as_list(&self) -> Result<impl Iterator<Item = &dyn PartialReflect>, ScriptError>;
 }
 
 impl<T: PartialReflect + ?Sized> PartialReflectExt for T {
@@ -39,8 +42,6 @@ impl<T: PartialReflect + ?Sized> PartialReflectExt for T {
         Ok(())
     }
 
-    /// If the type is an option, returns either the inner value or None if the option is None.
-    /// Errors if the type is not an option.
     fn as_option(&self) -> Result<Option<&dyn PartialReflect>, ScriptError> {
         self.expect_type(Some("core"), "Option")?;
 
@@ -54,6 +55,19 @@ impl<T: PartialReflect + ?Sized> PartialReflectExt for T {
 
         unreachable!("core::Option is an enum with a tuple variant")
     }
+
+    fn as_list(&self) -> Result<impl Iterator<Item = &dyn PartialReflect>, ScriptError> {
+        if let bevy::reflect::ReflectRef::List(l) = self.reflect_ref() {
+            Ok(l.iter())
+        } else {
+            Err(ScriptError::new_runtime_error(format!(
+                "Expected list-like type from crate core, but got {}",
+                self.get_represented_type_info()
+                    .map(|ti| ti.type_path())
+                    .unwrap_or_else(|| "dynamic type with no type information")
+            )))
+        }
+    }
 }
 
 #[cfg(test)]