feat: allow the conversion of lua functions into ScriptValue via DynamicScriptFunction (#396)

# Summary
Because `mlua::Function`'s store a pointer to their lua context, it's
possible to call these functions without direct access to a lua context.
This allows us to convert a lua function into a `DynamicScriptFunction`
which can be marshalled as a `ScriptValue` and arbitrarilly stored on
the rust side. However this will cause issues if your script contexts
get unloaded, in the form of panics most likely

Author: makspll

assets/tests/callback_to_dynamic_function/can_convert_lua_fn_to_dynamic_function.lua

@@ -0,0 +1,10 @@
+local my_fn = into_script_function(
+    function(string, list)
+        print(string, list)
+        assert(string == "test", "string is not test got: " .. string)
+        assert(list[1] == "test", "list[1] is not test, got: ".. list[1])
+    end
+)
+
+my_fn("test", {"test"})
+

crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs

@@ -2,10 +2,11 @@ use super::reference::LuaReflectReference;
 use bevy_mod_scripting_core::{
     asset::Language,
     bindings::{function::script_function::FunctionCallContext, script_value::ScriptValue},
+    error::InteropError,
 };
 use mlua::{FromLua, IntoLua, Value, Variadic};
 use std::{
-    collections::HashMap,
+    collections::{HashMap, VecDeque},
     ops::{Deref, DerefMut},
 };
 
@@ -51,6 +52,20 @@ impl FromLua for LuaScriptValue {
             Value::Integer(i) => ScriptValue::Integer(i as i64),
             Value::Number(n) => ScriptValue::Float(n),
             Value::String(s) => ScriptValue::String(s.to_str()?.to_owned().into()),
+            Value::Function(f) => ScriptValue::Function(
+                (move |_context: FunctionCallContext, args: VecDeque<ScriptValue>| {
+                    println!("Lua function called with args: {:?}", args);
+                    match f.call::<LuaScriptValue>(
+                        args.into_iter()
+                            .map(LuaScriptValue)
+                            .collect::<Variadic<_>>(),
+                    ) {
+                        Ok(v) => v.0,
+                        Err(e) => ScriptValue::Error(InteropError::external_error(Box::new(e))),
+                    }
+                })
+                .into(),
+            ),
             Value::Table(table) => {
                 // check the key types, if strings then it's a map
                 let mut iter = table.pairs::<Value, LuaScriptValue>();

crates/testing_crates/script_integration_test_harness/src/test_functions.rs

@@ -17,8 +17,8 @@ use bevy_mod_scripting_core::{
             script_function::{DynamicScriptFunctionMut, FunctionCallContext},
         },
         pretty_print::DisplayWithWorld,
-        ReflectReference, ScriptComponentRegistration, ScriptResourceRegistration,
-        ScriptTypeRegistration, ScriptValue,
+        DynamicScriptFunction, ReflectReference, ScriptComponentRegistration,
+        ScriptResourceRegistration, ScriptTypeRegistration, ScriptValue,
     },
     error::InteropError,
 };
@@ -144,6 +144,7 @@ pub fn register_test_functions(world: &mut App) {
             "noop_4_args",
             |_a: ScriptValue, _b: ScriptValue, _c: ScriptValue, _d: ScriptValue| {},
         )
+        .register("into_script_function", |f: DynamicScriptFunction| f)
         .register(
             "assert_str_eq",
             |s1: String, s2: String, reason: Option<String>| {