get static calls working

Author: makspll

crates/bevy_mod_scripting_core/src/bindings/query.rs

@@ -104,7 +104,10 @@ impl ScriptQueryBuilder {
 
 #[derive(Clone, Reflect)]
 #[reflect(opaque)]
-pub struct ScriptQueryResult(pub Entity, pub Vec<ReflectReference>);
+pub struct ScriptQueryResult {
+    pub entity: Entity,
+    pub components: Vec<ReflectReference>,
+}
 
 impl WorldCallbackAccess {
     pub fn query(
@@ -159,7 +162,10 @@ impl<'w> WorldAccessGuard<'w> {
                             reflect_path: ParsedPath(vec![]),
                         })
                         .collect();
-                    ScriptQueryResult(r.id(), references)
+                    ScriptQueryResult {
+                        entity: r.id(),
+                        components: references,
+                    }
                 })
                 .collect())
         })

crates/bevy_mod_scripting_core/src/error.rs

@@ -18,7 +18,9 @@ use thiserror::Error;
 
 use crate::{
     bindings::{
-        access_map::DisplayCodeLocation, pretty_print::{DisplayWithWorld, DisplayWithWorldAndDummy}, ReflectAllocationId, ReflectBase, ReflectBaseType, ReflectReference
+        access_map::DisplayCodeLocation,
+        pretty_print::{DisplayWithWorld, DisplayWithWorldAndDummy},
+        ReflectAllocationId, ReflectBase, ReflectBaseType, ReflectReference,
     },
     impl_dummy_display,
     prelude::ScriptValue,
@@ -201,16 +203,16 @@ impl From<InteropError> for ScriptError {
     }
 }
 
-pub trait FlattenError<O,E> {
+pub trait FlattenError<O, E> {
     fn flatten_interop_error(self) -> Result<O, E>;
 }
 
-impl <O>FlattenError<O, InteropError> for Result<Result<O,InteropError>, InteropError> {
+impl<O> FlattenError<O, InteropError> for Result<Result<O, InteropError>, InteropError> {
     fn flatten_interop_error(self) -> Result<O, InteropError> {
         match self {
             Ok(Ok(o)) => Ok(o),
             Ok(Err(e)) => Err(e),
-            Err(e) => Err(e)
+            Err(e) => Err(e),
         }
     }
 }
@@ -254,8 +256,14 @@ impl InteropError {
 
     /// Thrown if access to the given reflection base is required but cannot be claimed.
     /// This is likely due to some other script already claiming access to the base.
-    pub fn cannot_claim_access(base: ReflectBaseType, location: Option<std::panic::Location<'static>>) -> Self {
-        Self(Arc::new(InteropErrorInner::CannotClaimAccess { base, location }))
+    pub fn cannot_claim_access(
+        base: ReflectBaseType,
+        location: Option<std::panic::Location<'static>>,
+    ) -> Self {
+        Self(Arc::new(InteropErrorInner::CannotClaimAccess {
+            base,
+            location,
+        }))
     }
 
     /// Thrown if a conversion into the given type is impossible.
@@ -266,11 +274,11 @@ impl InteropError {
 
     /// Thrown if a conversion was not fully completed, as a better conversion exists.
     /// If a function might throw this error it should be handled by the caller.
-    /// 
+    ///
     /// A user seeing this error is evidence of unfinished logic.
     pub fn better_conversion_exists<T>() -> Self {
-        Self(Arc::new(InteropErrorInner::BetterConversionExists{
-            context: std::any::type_name::<T>().to_string()
+        Self(Arc::new(InteropErrorInner::BetterConversionExists {
+            context: std::any::type_name::<T>().to_string(),
         }))
     }
 
@@ -343,10 +351,7 @@ impl InteropError {
     }
 
     /// Thrown when an error happens in a function call. The inner error provides details on the error.
-    pub fn function_interop_error(
-        function_info: &FunctionInfo,
-        error: InteropError,
-    ) -> Self {
+    pub fn function_interop_error(function_info: &FunctionInfo, error: InteropError) -> Self {
         Self(Arc::new(InteropErrorInner::FunctionInteropError {
             function_name: function_info
                 .name()
@@ -366,17 +371,27 @@ impl InteropError {
     pub fn function_arg_conversion_error(argument: String, error: InteropError) -> Self {
         Self(Arc::new(InteropErrorInner::FunctionArgConversionError {
             argument,
-            error
+            error,
         }))
     }
     pub fn length_mismatch(expected: usize, got: usize) -> Self {
-        Self(Arc::new(InteropErrorInner::LengthMismatch { expected, got }))
+        Self(Arc::new(InteropErrorInner::LengthMismatch {
+            expected,
+            got,
+        }))
     }
-    
+
     pub fn external_error(error: Box<dyn std::error::Error + Send + Sync>) -> Self {
         Self(Arc::new(InteropErrorInner::OtherError { error }))
     }
 
+    pub fn missing_function(on: TypeId, function_name: String) -> Self {
+        Self(Arc::new(InteropErrorInner::MissingFunctionError {
+            on,
+            function_name,
+        }))
+    }
+
     pub fn inner(&self) -> &InteropErrorInner {
         &self.0
     }
@@ -418,7 +433,7 @@ pub enum InteropErrorInner {
         into: TypeId,
     },
     BetterConversionExists {
-        context: String
+        context: String,
     },
     TypeMismatch {
         expected: TypeId,
@@ -465,13 +480,17 @@ pub enum InteropErrorInner {
     FunctionCallError {
         inner: FunctionError,
     },
+    MissingFunctionError {
+        on: TypeId,
+        function_name: String,
+    },
     FunctionInteropError {
         function_name: String,
         error: InteropError,
     },
     FunctionArgConversionError {
         argument: String,
-        error: InteropError
+        error: InteropError,
     },
     OtherError {
         error: Box<dyn std::error::Error + Send + Sync>,
@@ -487,7 +506,13 @@ impl PartialEq for InteropErrorInner {
 impl DisplayWithWorld for InteropErrorInner {
     fn display_with_world(&self, world: crate::bindings::WorldGuard) -> String {
         match self {
-            
+            InteropErrorInner::MissingFunctionError { on, function_name } => {
+                format!(
+                    "Could not find function: {} for type: {}",
+                    function_name,
+                    on.display_with_world(world)
+                )
+            },
             InteropErrorInner::UnregisteredBase { base } => {
                 format!("Unregistered base type: {}", base.display_with_world(world))
             }
@@ -629,4 +654,4 @@ impl Default for InteropErrorInner {
     fn default() -> Self {
         InteropErrorInner::StaleWorldAccess
     }
-}
+}

crates/bevy_mod_scripting_functions/Cargo.toml

@@ -12,8 +12,7 @@ categories = ["game-development"]
 readme = "readme.md"
 
 [features]
-default = ["core_functions"]
-core_functions = ["bevy_mod_scripting_core"]
+
 
 
 [dependencies]
@@ -22,4 +21,4 @@ bevy = { workspace = true, features = [
 ] }
 uuid = "*"
 smol_str = "*"
-bevy_mod_scripting_core = { workspace = true, optional = true }
+bevy_mod_scripting_core = { workspace = true }

crates/bevy_mod_scripting_functions/src/core.rs

@@ -24,9 +24,7 @@ use bindings::{
 use error::InteropError;
 use reflection_extensions::TypeIdExtensions;
 
-use crate::namespaced_register::NamespaceBuilder;
-
-pub struct CoreFunctionsPlugin;
+use crate::{bevy_bindings::LuaBevyScriptingPlugin, namespaced_register::NamespaceBuilder};
 
 pub trait RegisterScriptFunction {
     fn overwrite_script_function<M, N, F>(&mut self, name: N, f: F) -> &mut Self
@@ -52,23 +50,11 @@ impl<S: 'static> RegisterScriptFunction for NamespaceBuilder<'_, S> {
     }
 }
 
-impl Plugin for CoreFunctionsPlugin {
-    fn build(&self, app: &mut App) {
-        let world = app.world_mut();
-        register_world_functions(world).expect("Failed to register world functions");
-
-        register_reflect_reference_functions(world)
-            .expect("Failed to register reflect reference functions");
-
-        register_script_type_registration_functions(world)
-            .expect("Failed to register script type registration functions");
-
-        register_script_query_builder_functions(world)
-            .expect("Failed to register script query builder functions");
-    }
+pub fn register_bevy_bindings(app: &mut App) {
+    app.add_plugins(LuaBevyScriptingPlugin);
 }
 
-fn register_world_functions(reg: &mut World) -> Result<(), FunctionRegistrationError> {
+pub fn register_world_functions(reg: &mut World) -> Result<(), FunctionRegistrationError> {
     NamespaceBuilder::<WorldCallbackAccess>::new(reg)
         .overwrite_script_function("spawn", |s: WorldCallbackAccess| Ok(Val(s.spawn()?)))
         .overwrite_script_function(
@@ -180,7 +166,9 @@ fn register_world_functions(reg: &mut World) -> Result<(), FunctionRegistrationE
     Ok(())
 }
 
-fn register_reflect_reference_functions(reg: &mut World) -> Result<(), FunctionRegistrationError> {
+pub fn register_reflect_reference_functions(
+    reg: &mut World,
+) -> Result<(), FunctionRegistrationError> {
     NamespaceBuilder::<ReflectReference>::new(reg)
         .overwrite_script_function(
             "display_ref",
@@ -273,7 +261,7 @@ fn register_reflect_reference_functions(reg: &mut World) -> Result<(), FunctionR
     Ok(())
 }
 
-fn register_script_type_registration_functions(
+pub fn register_script_type_registration_functions(
     registry: &mut World,
 ) -> Result<(), FunctionRegistrationError> {
     NamespaceBuilder::<ScriptTypeRegistration>::new(registry)
@@ -290,7 +278,7 @@ fn register_script_type_registration_functions(
     Ok(())
 }
 
-fn register_script_query_builder_functions(
+pub fn register_script_query_builder_functions(
     registry: &mut World,
 ) -> Result<(), FunctionRegistrationError> {
     NamespaceBuilder::<ScriptQueryBuilder>::new(registry)
@@ -322,11 +310,14 @@ fn register_script_query_builder_functions(
     Ok(())
 }
 
-// fn register_script_query_result_functions(
-//     registry: &mut FunctionRegistry,
-// ) -> Result<(), FunctionRegistrationError> {
-//     NamespaceBuilder::<ScriptQueryResult>::new(registry)
-//         .overwrite_script_function("entity", |s: Ref<ScriptQueryResult>| s.entity())
-//         .overwrite_script_function("components", |s: Ref<ScriptQueryResult>| s.components());
-//     Ok(())
-// }
+pub fn register_script_query_result_functions(
+    world: &mut World,
+) -> Result<(), FunctionRegistrationError> {
+    NamespaceBuilder::<ScriptQueryResult>::new(world)
+        .overwrite_script_function("entity", |s: Ref<ScriptQueryResult>| Val::new(s.entity))
+        .overwrite_script_function("components", |s: Ref<ScriptQueryResult>| {
+            let components = s.components.to_vec();
+            Val::new(components)
+        });
+    Ok(())
+}

crates/bevy_mod_scripting_functions/src/lib.rs

@@ -1,19 +1,31 @@
 use ::bevy::prelude::*;
-#[cfg(feature = "core_functions")]
 pub mod bevy_bindings;
-#[cfg(feature = "core_functions")]
 pub mod core;
 
 pub mod namespaced_register;
 
 pub use core::*;
 pub use namespaced_register::*;
 
-pub struct BevyFunctionsPlugin;
+pub struct ScriptFunctionsPlugin;
 
-impl Plugin for BevyFunctionsPlugin {
+impl Plugin for ScriptFunctionsPlugin {
     fn build(&self, app: &mut App) {
-        #[cfg(feature = "core_functions")]
-        app.add_plugins(core::CoreFunctionsPlugin);
+        register_bevy_bindings(app);
+        let world = app.world_mut();
+
+        register_world_functions(world).expect("Failed to register world functions");
+
+        register_reflect_reference_functions(world)
+            .expect("Failed to register reflect reference functions");
+
+        register_script_type_registration_functions(world)
+            .expect("Failed to register script type registration functions");
+
+        register_script_query_builder_functions(world)
+            .expect("Failed to register script query builder functions");
+
+        register_script_query_result_functions(world)
+            .expect("Failed to register script query result functions");
     }
 }

crates/languages/bevy_mod_scripting_lua/Cargo.toml

@@ -42,9 +42,7 @@ path = "src/lib.rs"
 [dependencies]
 bevy = { workspace = true, default-features = false }
 bevy_mod_scripting_core = { workspace = true, features = ["mlua_impls"] }
-bevy_mod_scripting_functions = { workspace = true, features = [
-    "core_functions",
-] }
+bevy_mod_scripting_functions = { workspace = true, features = [] }
 bevy_mod_scripting_derive = { path = "../../bevy_mod_scripting_derive" }
 mlua = { workspace = true, features = ["vendored", "send", "macros"] }
 parking_lot = "0.12.1"