remove need for world jerry-rig, use static reference

Author: makspll

assets/scripts/bevy_api.lua

@@ -9,20 +9,20 @@ end
 
 function on_event()
     -- send exit event, to finish after one call
-    world:exit()
+    world.exit()
 
     print(entity) 
     print(script)
     print(world)
 
-    -- print(world:hello(entity, entity))
-    -- print(world:test_vec({entity, entity})[1])
+    -- print(world.hello(entity, entity))
+    -- print(world.test_vec({entity, entity})[1])
 
 
-    local my_component_type = world:get_type_by_name("MyComponent")
+    local my_component_type = world.get_type_by_name("MyComponent")
     print("MyComponent type: ", my_component_type:short_name())
 
-    local comp = world:get_component(entity, my_component_type)
+    local comp = world.get_component(entity, my_component_type)
     print("Before script: ", comp:print_value())
 
     print("\noption")
@@ -142,18 +142,18 @@ function on_event()
     -- print("F")
 
 
-    -- world:exit()
+    -- world.exit()
     -- do return end
     -- print("============")
 
     -- -- this is an example of something impossible to achieve with plain bevy reflection under the hood
     -- comp.mat3[1][1] = 42
 
     -- -- now let's retrieve these again to see if we actually changed their values permanently
-    -- comp = world:get_component(entity,my_component_type)
+    -- comp = world.get_component(entity,my_component_type)
 
     -- print("After script:")
     -- print(comp)
 
-    -- world:exit()
+    -- world.exit()
 end

assets/scripts/coroutines.lua

@@ -17,7 +17,7 @@ function on_update()
             coroutine.resume(my_routine)
         else
             print("Couroutine has finished, no longer running")
-            world:exit()
+            world.exit()
         end
     end
 end

assets/scripts/dynamic_queries.lua

@@ -1,23 +1,23 @@
-local component_a = world:get_type_by_name("ComponentA")
-local component_b = world:get_type_by_name("ComponentB")
-local component_c = world:get_type_by_name("ComponentC")
+local component_a = world.get_type_by_name("ComponentA")
+local component_b = world.get_type_by_name("ComponentB")
+local component_c = world.get_type_by_name("ComponentC")
 
 print("Querying for entities with component_a and without component_c")
-for entity, c in world:query(component_a):without(component_c):iter() do
+for entity, c in world.query(component_a):without(component_c):iter() do
 	print("Entity with index: " .. entity:index() .. " component: " .. tostring(c))
 end
 
 print("Querying for entities with component_b and without component_a")
-for entity, c in world:query(component_b):without(component_a):iter() do
+for entity, c in world.query(component_b):without(component_a):iter() do
 	print("Entity with index: " .. entity:index() .. " component: " .. tostring(c))
 end
 
 print("Querying for all components at once")
-for entity, c1,c2,c3 in world:query(component_a, component_b, component_c):iter() do
+for entity, c1,c2,c3 in world.query(component_a, component_b, component_c):iter() do
 	print("Entity with index: " .. entity:index())
 	print("\tComponentA: " .. tostring(c1))
 	print("\tComponentB: " .. tostring(c2))
 	print("\tComponentC: " .. tostring(c3))
 end
 
-world:exit()
+world.exit()

assets/scripts/game_of_life.lua

@@ -1,8 +1,8 @@
 math.randomseed(os.time())
 
 function init()
-    local LifeState = world:get_type_by_name("LifeState")
-    local life_state = world:get_component(entity,LifeState)
+    local LifeState = world.get_type_by_name("LifeState")
+    local life_state = world.get_component(entity,LifeState)
     local cells = life_state.cells
 
     -- set some cells alive
@@ -13,15 +13,15 @@ function init()
 end
 
 function on_update()
-    local LifeState = world:get_type_by_name("LifeState")
-    local Settings = world:get_type_by_name("Settings")
+    local LifeState = world.get_type_by_name("LifeState")
+    local Settings = world.get_type_by_name("Settings")
 
-    local life_state = world:get_component(entity,LifeState)
+    local life_state = world.get_component(entity,LifeState)
     -- note currently this is a copy of the cells, as of now the macro does not automatically support Vec<T> proxies by reference
     local cells = life_state.cells
 
     -- note that here we do not make use of LuaProxyable and just go off pure reflection
-    local settings = world:get_resource(Settings)
+    local settings = world.get_resource(Settings)
     local dimensions = settings.physical_grid_dimensions
 
 

crates/bevy_mod_scripting_core/src/bindings/access_map.rs

@@ -148,7 +148,6 @@ impl ReflectAccessId {
             ReflectBase::Resource(id) => Some(Self::for_component_id(id)),
             ReflectBase::Component(_, id) => Some(Self::for_component_id(id)),
             ReflectBase::Owned(id) => Some(Self::for_allocation(id)),
-            ReflectBase::World => None,
         }
     }
 }

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

@@ -13,6 +13,7 @@ use bevy::reflect::{
     },
     PartialReflect,
 };
+use script_function::CallerContext;
 
 use crate::{
     error::{FlattenError, InteropError, InteropErrorInner, ScriptError, ScriptResult},
@@ -32,6 +33,7 @@ pub trait CallScriptFunction {
         &self,
         args: I,
         world: WorldGuard,
+        context: CallerContext,
     ) -> Result<ScriptValue, InteropError>;
 }
 
@@ -40,26 +42,22 @@ impl CallScriptFunction for DynamicFunction<'_> {
         &self,
         args: I,
         world: WorldGuard,
+        context: CallerContext,
     ) -> Result<ScriptValue, InteropError> {
-        let mut args = args.into_iter().peekable();
-
-        let add_world =
-            self.first_arg_is_world() && args.peek().map_or(true, |a| a != &ScriptValue::World);
+        let args = args.into_iter();
 
+        let add_context = self.has_caller_context_arg();
         let mut args_list = ArgList::new();
 
-        if add_world {
+        if add_context {
+            args_list = args_list.push_arg(ArgValue::Owned(Box::new(context)));
             args_list = args_list.push_arg(ArgValue::Owned(Box::new(
                 WorldCallbackAccess::from_guard(world.clone()),
             )));
         }
 
         for arg in args {
-            let arg_val = ArgValue::Owned(match arg {
-                ScriptValue::World => Box::new(WorldCallbackAccess::from_guard(world.clone())),
-                _ => Box::new(arg),
-            });
-
+            let arg_val = ArgValue::Owned(Box::new(arg));
             args_list = args_list.push_arg(arg_val);
         }
 
@@ -81,13 +79,13 @@ impl CallScriptFunction for DynamicFunction<'_> {
 }
 
 pub trait DynamicFunctionExt {
-    fn first_arg_is_world(&self) -> bool;
+    fn has_caller_context_arg(&self) -> bool;
 }
 
 impl DynamicFunctionExt for DynamicFunction<'_> {
-    fn first_arg_is_world(&self) -> bool {
+    fn has_caller_context_arg(&self) -> bool {
         self.info().args().first().map_or(false, |arg| {
-            arg.type_id() == std::any::TypeId::of::<WorldCallbackAccess>()
+            arg.type_id() == std::any::TypeId::of::<CallerContext>()
         })
     }
 }

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

@@ -8,7 +8,7 @@ use crate::{
     prelude::{ScriptValue, WorldCallbackAccess},
 };
 use bevy::{
-    prelude::{AppFunctionRegistry, IntoFunction, World},
+    prelude::{AppFunctionRegistry, IntoFunction, Reflect, World},
     reflect::{
         func::{DynamicFunction, FunctionInfo},
         FromReflect, GetTypeRegistration, PartialReflect, TypeRegistration, TypeRegistry, Typed,
@@ -85,7 +85,7 @@ macro_rules! register_tuple_dependencies {
 }
 
 no_type_dependencies!(ReflectReference, InteropError);
-self_type_dependency_only!(WorldCallbackAccess);
+self_type_dependency_only!(WorldCallbackAccess, CallerContext);
 
 recursive_type_dependencies!(
     (Val<T> where T: GetTypeRegistration),
@@ -103,12 +103,24 @@ pub trait GetFunctionTypeDependencies<Marker> {
     fn register_type_dependencies(registry: &mut TypeRegistry);
 }
 
-/// The Script Function equivalent for dynamic functions
+/// The caller context when calling a script function.
+/// Functions can choose to react to caller preferences such as converting 1-indexed numbers to 0-indexed numbers
+#[derive(Clone, Copy, Debug, Reflect)]
+pub struct CallerContext {
+    pub convert_to_0_indexed: bool,
+}
+
+/// The Script Function equivalent for dynamic functions. Currently unused
 /// TODO: have a separate function registry to avoid the need for boxing script args every time
 pub struct DynamicScriptFunction {
     pub info: FunctionInfo,
-    pub func:
-        Arc<dyn Fn(WorldCallbackAccess, Vec<ScriptValue>) -> Result<ScriptValue, InteropError>>,
+    pub func: Arc<
+        dyn Fn(
+            CallerContext,
+            WorldCallbackAccess,
+            Vec<ScriptValue>,
+        ) -> Result<ScriptValue, InteropError>,
+    >,
 }
 
 macro_rules! impl_script_function {
@@ -117,31 +129,39 @@ macro_rules! impl_script_function {
         // fn(T1...Tn) -> O
         impl_script_function!(@ $( $param ),* : -> O => O );
         // fn(WorldCallbackAccess, T1...Tn) -> O
-        impl_script_function!(@ $( $param ),* : (callback: WorldCallbackAccess) -> O => O);
+        impl_script_function!(@ $( $param ),* : ,(callback: WorldCallbackAccess) -> O => O);
+        // fn(CallerContext, WorldCallbackAccess, T1...Tn) -> O
+        impl_script_function!(@ $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => O);
+
         // fn(T1...Tn) -> Result<O, InteropError>
         impl_script_function!(@ $( $param ),* : -> O => Result<O, InteropError> where s);
         // fn(WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
-        impl_script_function!(@ $( $param ),* : (callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+        impl_script_function!(@ $( $param ),* : ,(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+        // fn(CallerContext, WorldCallbackAccess, T1...Tn) -> Result<O, InteropError>
+        impl_script_function!(@ $( $param ),* : (context: CallerContext),(callback: WorldCallbackAccess) -> O => Result<O, InteropError> where s);
+
     };
 
-    (@ $( $param:ident ),* : $(($callback:ident: $callbackty:ty))? -> O => $res:ty $(where $out:ident)?) => {
+    (@ $( $param:ident ),* :  $(($context:ident: $contextty:ty))? $(,($callback:ident: $callbackty:ty))? -> O => $res:ty $(where $out:ident)?) => {
         #[allow(non_snake_case)]
         impl<
             'env,
             $( $param: FromScript, )*
             O,
             F
         > ScriptFunction<'env,
-            fn( $( $callbackty, )? $($param ),* ) -> $res
+            fn( $($contextty,)? $( $callbackty, )? $($param ),* ) -> $res
         > for F
         where
             O: IntoScript,
-            F: Fn( $( $callbackty, )? $($param ),* ) -> $res + Send + Sync + 'static,
+            F: Fn(  $($contextty,)? $( $callbackty, )? $($param ),* ) -> $res + Send + Sync + 'static,
             $( $param::This<'env>: Into<$param>),*
         {
+            #[allow(unused_variables)]
             fn into_dynamic_function(self) -> DynamicFunction<'static> {
-                (move |world: WorldCallbackAccess, $( $param: ScriptValue ),* | {
+                (move |caller_context: CallerContext, world: WorldCallbackAccess, $( $param: ScriptValue ),* | {
                     let res: Result<ScriptValue, InteropError> = (|| {
+                        $( let $context = caller_context; )?
                         $( let $callback = world.clone(); )?
                         let world = world.try_read()?;
                         world.begin_access_scope()?;
@@ -153,7 +173,7 @@ macro_rules! impl_script_function {
                                 let $param = <$param>::from_script($param, world.clone())
                                     .map_err(|e| InteropError::function_arg_conversion_error(current_arg.to_string(), e))?;
                             )*
-                            let out = self( $( $callback, )? $( $param.into(), )* );
+                            let out = self( $( $context,)? $( $callback, )? $( $param.into(), )* );
                             $(
                                 let $out = out?;
                                 let out = $out;
@@ -188,8 +208,8 @@ macro_rules! impl_script_function_type_dependencies{
     };
 }
 
-bevy::utils::all_tuples!(impl_script_function, 0, 14, T);
-bevy::utils::all_tuples!(impl_script_function_type_dependencies, 0, 14, T);
+bevy::utils::all_tuples!(impl_script_function, 0, 13, T);
+bevy::utils::all_tuples!(impl_script_function_type_dependencies, 0, 13, T);
 
 /// Utility for quickly checking your type can be used as an argument in a script function
 ///

crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs

@@ -77,7 +77,6 @@ impl ReflectReferencePrinter {
             ReflectBase::Component(e, _) => format!("Component on entity {}", e),
             ReflectBase::Resource(_) => "Resource".to_owned(),
             ReflectBase::Owned(_) => "Allocation".to_owned(),
-            ReflectBase::World => "World".to_owned(),
         };
 
         out.push_str(&format!("{}({})", base_kind, type_path));
@@ -403,7 +402,6 @@ impl DisplayWithWorld for ScriptValue {
             ScriptValue::Integer(i) => i.to_string(),
             ScriptValue::Float(f) => f.to_string(),
             ScriptValue::String(cow) => cow.to_string(),
-            ScriptValue::World => "World".to_owned(),
             ScriptValue::Error(script_error) => script_error.to_string(),
             ScriptValue::List(vec) => {
                 let mut string = String::new();