feat! add type cache table global, and refactor GetTypeDependencies to work better with nested types

Author: makspll

assets/tests/globals/type_cache_available.lua

@@ -0,0 +1,6 @@
+
+function on_test()
+    local my_type = types.TestResource;
+    assert(my_type ~= nil, "Type t.TestResource is not available");
+    assert(my_type:short_name() == "TestResource", "Type t.TestResource:short_name() is not correct: " .. my_type:short_name());
+end

crates/bevy_mod_scripting_core/src/bindings/function/arg_meta.rs

@@ -4,7 +4,7 @@ use std::{ffi::OsString, path::PathBuf};
 
 use crate::{
     bindings::{script_value::ScriptValue, ReflectReference},
-    docgen::typed_through::TypedThrough,
+    docgen::typed_through::TypedThrough, error::InteropError,
 };
 
 use super::{
@@ -77,6 +77,8 @@ impl<T> ArgMeta for Val<T> {}
 impl<T> ArgMeta for Ref<'_, T> {}
 impl<T> ArgMeta for Mut<'_, T> {}
 
+impl<T> ArgMeta for Result<T, InteropError> {}
+
 impl<T> ArgMeta for Option<T> {
     fn default_value() -> Option<ScriptValue> {
         Some(ScriptValue::Unit)

crates/bevy_mod_scripting_core/src/bindings/function/from.rs

@@ -469,6 +469,17 @@ where
 pub struct Union<T1, T2>(Result<T1, T2>);
 
 impl<T1, T2> Union<T1, T2> {
+    /// Create a new union with the left value.
+    pub fn new_left(value: T1) -> Self {
+        Union(Ok(value))
+    }
+
+    /// Create a new union with the right value.
+    pub fn new_right(value: T2) -> Self {
+        Union(Err(value))
+    }
+
+
     /// Try interpret the union as the left type
     pub fn into_left(self) -> Result<T1, T2> {
         match self.0 {
@@ -484,6 +495,14 @@ impl<T1, T2> Union<T1, T2> {
             Ok(l) => Err(l),
         }
     }
+     
+    /// Map the union to another type
+    pub fn map_both<U1, U2, F: Fn(T1) -> U1, G: Fn(T2) -> U2>(self, f: F, g: G) -> Union<U1, U2> {
+        match self.0 {
+            Ok(t) => Union(Ok(f(t))),
+            Err(t) => Union(Err(g(t))),
+        }
+    }
 }
 
 impl<T1: FromScript, T2: FromScript> FromScript for Union<T1, T2>

crates/bevy_mod_scripting_core/src/bindings/function/into.rs

@@ -11,7 +11,7 @@ use crate::{
 };
 
 use super::{
-    from::Val,
+    from::{Union, Val},
     script_function::{DynamicScriptFunction, DynamicScriptFunctionMut},
 };
 
@@ -165,6 +165,15 @@ impl<T: IntoScript, const N: usize> IntoScript for [T; N] {
     }
 }
 
+impl <T1: IntoScript, T2: IntoScript> IntoScript for Union<T1,T2> {
+    fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
+        match self.into_left() {
+            Ok(left) => left.into_script(world),
+            Err(right) => right.into_script(world),
+        }
+    }
+} 
+
 impl<V: IntoScript> IntoScript for HashMap<String, V> {
     fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
         let mut map = HashMap::new();

crates/bevy_mod_scripting_core/src/bindings/function/mod.rs

@@ -21,8 +21,7 @@ mod test {
                 from::{Ref, Union, Val},
                 namespace::IntoNamespace,
                 script_function::AppScriptFunctionRegistry,
-            },
-            script_value::ScriptValue,
+            }, script_value::ScriptValue
         },
         docgen::typed_through::TypedThrough,
     };
@@ -135,6 +134,16 @@ mod test {
             test_is_valid_arg::<Ref<'_, T>>();
         }
 
+        fn test_union<T>()
+        where
+            T: TypedScriptArgument + TypedScriptReturn,
+            T: GetTypeRegistration,
+            for<'a> T::This<'a>: Into<T>,
+        {
+            test_is_valid_arg_and_return::<Union<T, T>>();
+            test_is_valid_arg_and_return::<Union<T, Union<T, T>>>();
+        }
+
         fn test_array<T, const N: usize>()
         where
             T: ScriptArgument + ScriptReturn,

crates/bevy_mod_scripting_core/src/bindings/function/type_dependencies.rs

@@ -10,7 +10,6 @@ use crate::{
 };
 use bevy::reflect::{FromReflect, GetTypeRegistration, TypeRegistry, Typed};
 use std::collections::HashMap;
-use std::hash::Hash;
 
 /// Functionally identical to [`GetTypeRegistration`] but without the 'static bound
 pub trait GetTypeDependencies {
@@ -81,13 +80,40 @@ recursive_type_dependencies!(
     (Val<T> where T: GetTypeRegistration),
     (Ref<'_, T>  where T: GetTypeRegistration),
     (Mut<'_, T>  where T: GetTypeRegistration),
-    (Result<T, InteropError>  where T: GetTypeRegistration),
+    // (Result<T, InteropError>  where T: GetTypeRegistration),
     ([T; N]  where T: GetTypeRegistration;Typed,, const N: usize => with Self),
-    (Option<T>  where T: GetTypeRegistration;FromReflect;Typed => with Self),
-    (Vec<T>  where T: GetTypeRegistration;FromReflect;Typed => with Self),
-    (HashMap<K,V> where K: GetTypeRegistration;FromReflect;Typed;Hash;Eq, V: GetTypeRegistration;FromReflect;Typed => with Self)
+    // (Option<T>  where T: GetTypeRegistration;FromReflect;Typed => with Self),
+    (Vec<T>  where T: GetTypeRegistration;FromReflect;Typed => with Self)
+    // (HashMap<K,V> where K: GetTypeRegistration;FromReflect;Typed;Hash;Eq, V: GetTypeRegistration;FromReflect;Typed => with Self)
 );
 
+
+impl <K> GetTypeDependencies for Option<K> 
+where 
+    K: GetTypeDependencies
+{
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        K::register_type_dependencies(registry);
+    }
+}
+
+impl <K, V> GetTypeDependencies for HashMap<K, V> 
+where 
+    K: GetTypeDependencies,
+    V: GetTypeDependencies
+{
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        K::register_type_dependencies(registry);
+        V::register_type_dependencies(registry);
+    }
+}
+
+impl <T: GetTypeDependencies> GetTypeDependencies for Result<T, InteropError> {
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        T::register_type_dependencies(registry);
+    }
+}
+
 impl<T1: GetTypeDependencies, T2: GetTypeDependencies> GetTypeDependencies for Union<T1, T2> {
     fn register_type_dependencies(registry: &mut TypeRegistry) {
         T1::register_type_dependencies(registry);

crates/bevy_mod_scripting_core/src/bindings/globals/core.rs

@@ -1,6 +1,11 @@
 //! Core globals exposed by the BMS framework
 
+use std::{collections::HashMap, sync::Arc};
+
 use bevy::{app::Plugin, ecs::reflect::AppTypeRegistry};
+use bevy_mod_scripting_derive::script_globals;
+
+use crate::{bindings::{function::from::{Union, Val}, ScriptComponentRegistration, ScriptResourceRegistration, ScriptTypeRegistration, WorldGuard}, error::InteropError};
 
 use super::AppScriptGlobalsRegistry;
 
@@ -10,12 +15,16 @@ pub struct CoreScriptGlobalsPlugin;
 impl Plugin for CoreScriptGlobalsPlugin {
     fn build(&self, _app: &mut bevy::app::App) {}
     fn finish(&self, app: &mut bevy::app::App) {
-        let global_registry = app
-            .world_mut()
+        register_static_core_globals(app.world_mut());
+        register_core_globals(app.world_mut());
+    }
+}
+
+fn register_static_core_globals(world: &mut bevy::ecs::world::World) {
+    let global_registry = world
             .get_resource_or_init::<AppScriptGlobalsRegistry>()
             .clone();
-        let type_registry = app
-            .world_mut()
+        let type_registry = world
             .get_resource_or_init::<AppTypeRegistry>()
             .clone();
         let mut global_registry = global_registry.write();
@@ -34,8 +43,32 @@ impl Plugin for CoreScriptGlobalsPlugin {
                     None,
                     global_name.into(),
                     documentation.into(),
-                )
+                );
             }
         }
-    }
 }
+
+#[script_globals(
+    bms_core_path = "crate",
+    name = "core_globals",
+)]
+impl CoreGlobals {
+    /// A cache of types normally available through the `world.get_type_by_name` function.
+    /// 
+    /// You can use this to avoid having to store type references.
+    fn types(guard: WorldGuard) -> Result<HashMap<String, Union<Val<ScriptTypeRegistration>, Union<Val<ScriptComponentRegistration>, Val<ScriptResourceRegistration>>>>, InteropError> {
+        let type_registry = guard.type_registry();
+        let type_registry = type_registry.read();
+        let mut type_cache = HashMap::<String, _>::default();
+        for registration in type_registry.iter(){
+            if let Some(ident) = registration.type_info().type_path_table().ident() {
+                let registration = ScriptTypeRegistration::new(Arc::new(registration.clone()));
+                let registration = guard.clone().get_type_registration(registration)?;
+                let registration = registration.map_both(Val::from, |u| u.map_both(Val::from, Val::from));
+                type_cache.insert(ident.to_string(), registration);
+            }
+        }
+        
+        Ok(type_cache)
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/globals/mod.rs

@@ -98,11 +98,11 @@ impl ScriptGlobalsRegistry {
         F: Fn(WorldGuard) -> Result<T, InteropError> + 'static + Send + Sync,
     >(
         &mut self,
-        name: Cow<'static, str>,
+        name: impl Into<Cow<'static, str>>,
         maker: F,
     ) -> Option<ScriptGlobal> {
         self.globals.insert(
-            name,
+            name.into(),
             ScriptGlobal {
                 maker: Some(Self::type_erase_maker(maker)),
                 documentation: None,
@@ -120,15 +120,15 @@ impl ScriptGlobalsRegistry {
         F: Fn(WorldGuard) -> Result<T, InteropError> + 'static + Send + Sync,
     >(
         &mut self,
-        name: Cow<'static, str>,
+        name: impl Into<Cow<'static, str>>,
         maker: F,
-        documentation: Cow<'static, str>,
+        documentation: impl Into<Cow<'static, str>>,
     ) -> Option<ScriptGlobal> {
         self.globals.insert(
-            name,
+            name.into(),
             ScriptGlobal {
                 maker: Some(Self::type_erase_maker(maker)),
-                documentation: Some(documentation),
+                documentation: Some(documentation.into()),
                 type_id: TypeId::of::<T>(),
                 type_information: Some(T::through_type_info()),
             },

crates/bevy_mod_scripting_core/src/bindings/world.rs

@@ -11,8 +11,7 @@ use super::{
         ReflectAccessKind, SubsetAccessMap,
     },
     function::{
-        namespace::Namespace,
-        script_function::{AppScriptFunctionRegistry, DynamicScriptFunction, FunctionCallContext},
+        from::Union, namespace::Namespace, script_function::{AppScriptFunctionRegistry, DynamicScriptFunction, FunctionCallContext}
     },
     pretty_print::DisplayWithWorld,
     schedule::AppScheduleRegistry,
@@ -549,6 +548,7 @@ impl<'w> WorldAccessGuard<'w> {
 /// Impl block for higher level world methods
 #[profiling::all_functions]
 impl WorldAccessGuard<'_> {
+    
     fn construct_from_script_value(
         &self,
         descriptor: impl Into<Cow<'static, str>>,
@@ -807,7 +807,7 @@ impl WorldAccessGuard<'_> {
         })
     }
 
-    /// get a type registration for the type
+    /// get a type registration for the type, without checking if it's a component or resource
     pub fn get_type_by_name(&self, type_name: String) -> Option<ScriptTypeRegistration> {
         let type_registry = self.type_registry();
         let type_registry = type_registry.read();
@@ -817,6 +817,38 @@ impl WorldAccessGuard<'_> {
             .map(|registration| ScriptTypeRegistration::new(Arc::new(registration.clone())))
     }
 
+    /// get a type erased type registration for the type including information about whether it's a component or resource
+    pub(crate) fn get_type_registration(&self, registration: ScriptTypeRegistration) -> Result<Union<ScriptTypeRegistration, Union<ScriptComponentRegistration, ScriptResourceRegistration>>, InteropError> {
+
+        let registration = match self.get_resource_type(registration)? {
+            Ok(res) => {
+                return Ok(Union::new_right(Union::new_right(res)));
+            }
+            Err(registration) => registration,
+        };
+
+        let registration = match self.get_component_type(registration)? {
+            Ok(comp) => {
+                return Ok(Union::new_right(Union::new_left(comp)));
+            }
+            Err(registration) => registration,
+        };
+
+        Ok(Union::new_left(registration))
+    }
+
+    /// Similar to [`Self::get_type_by_name`] but returns a type erased [`ScriptTypeRegistration`], [`ScriptComponentRegistration`] or [`ScriptResourceRegistration`] 
+    /// depending on the underlying type and state of the world.
+    pub fn get_type_registration_by_name(&self, type_name: String) -> Result<Option<Union<ScriptTypeRegistration, Union<ScriptComponentRegistration, ScriptResourceRegistration>>>, InteropError> {
+        let val = self.get_type_by_name(type_name);
+        Ok(match val {
+            Some(registration) => {
+                Some(self.get_type_registration(registration)?)
+            }
+            None => None,
+        })
+    }
+
     /// get a schedule by name
     pub fn get_schedule_by_name(&self, schedule_name: String) -> Option<ReflectSchedule> {
         let schedule_registry = self.schedule_registry();

crates/bevy_mod_scripting_functions/src/core.rs

@@ -30,6 +30,7 @@ use bindings::{
 };
 use error::InteropError;
 use reflection_extensions::{PartialReflectExt, TypeIdExtensions};
+
 pub fn register_bevy_bindings(app: &mut App) {
     #[cfg(feature = "bevy_bindings")]
     app.add_plugins(crate::bevy_bindings::LuaBevyScriptingPlugin);
@@ -45,39 +46,10 @@ impl World {
     fn get_type_by_name(
         ctxt: FunctionCallContext,
         type_name: String,
-    ) -> Result<Option<ReflectReference>, InteropError> {
+    ) -> Result<Option<Union<Val<ScriptTypeRegistration>, Union<Val<ScriptComponentRegistration>, Val<ScriptResourceRegistration>>>>, InteropError> {
         profiling::function_scope!("get_type_by_name");
         let world = ctxt.world()?;
-        let val = world.get_type_by_name(type_name);
-
-        Ok(match val {
-            Some(registration) => {
-                let allocator = world.allocator();
-
-                let registration = match world.get_resource_type(registration)? {
-                    Ok(res) => {
-                        let mut allocator = allocator.write();
-                        return Ok(Some(ReflectReference::new_allocated(res, &mut allocator)));
-                    }
-                    Err(registration) => registration,
-                };
-
-                let registration = match world.get_component_type(registration)? {
-                    Ok(comp) => {
-                        let mut allocator = allocator.write();
-                        return Ok(Some(ReflectReference::new_allocated(comp, &mut allocator)));
-                    }
-                    Err(registration) => registration,
-                };
-
-                let mut allocator = allocator.write();
-                Some(ReflectReference::new_allocated(
-                    registration,
-                    &mut allocator,
-                ))
-            }
-            None => None,
-        })
+        world.get_type_registration_by_name(type_name).map(|v| v.map(|v| v.map_both(Val::from, |u| u.map_both(Val::from, Val::from))))
     }
 
     /// Retrieves the schedule with the given name, Also ensures the schedule is initialized before returning it.