feat!: Add BMSPlugin group, feature flag for bindings per bevy crate & global registration options

Author: makspll

Cargo.toml

@@ -21,7 +21,18 @@ bench = false
 features = ["lua54", "rhai"]
 
 [features]
-default = ["core_functions", "bevy_bindings"]
+default = [
+    "core_functions",
+    "bevy_bindings",
+    "bevy_core_bindings",
+    "bevy_ecs_bindings",
+    "bevy_hierarchy_bindings",
+    "bevy_input_bindings",
+    "bevy_math_bindings",
+    "bevy_reflect_bindings",
+    "bevy_time_bindings",
+    "bevy_transform_bindings",
+]
 
 lua = [
     "bevy_mod_scripting_lua",
@@ -40,6 +51,15 @@ luau = ["bevy_mod_scripting_lua/luau", "lua"]
 core_functions = ["bevy_mod_scripting_functions/core_functions"]
 bevy_bindings = ["bevy_mod_scripting_functions/bevy_bindings"]
 
+bevy_core_bindings = ["bevy_mod_scripting_functions/bevy_core"]
+bevy_ecs_bindings = ["bevy_mod_scripting_functions/bevy_ecs"]
+bevy_hierarchy_bindings = ["bevy_mod_scripting_functions/bevy_hierarchy"]
+bevy_input_bindings = ["bevy_mod_scripting_functions/bevy_input"]
+bevy_math_bindings = ["bevy_mod_scripting_functions/bevy_math"]
+bevy_reflect_bindings = ["bevy_mod_scripting_functions/bevy_reflect"]
+bevy_time_bindings = ["bevy_mod_scripting_functions/bevy_time"]
+bevy_transform_bindings = ["bevy_mod_scripting_functions/bevy_transform"]
+
 # optional
 unsafe_lua_modules = ["bevy_mod_scripting_lua?/unsafe_lua_modules"]
 mlua_serialize = ["bevy_mod_scripting_lua?/mlua_serialize"]

crates/bevy_api_gen/templates/mod.tera

@@ -4,17 +4,8 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 {% filter prettyplease %}
 {%- for crate in crates %}
+    #[cfg(feature="{{crate.name}}")]
     pub mod {{ crate.name }};
 {% endfor -%}
 
-pub struct {{ api_name }};
-
-impl ::bevy::app::Plugin for {{ api_name }} {
-    fn build(&self, app: &mut ::bevy::prelude::App) {
-        {% for crate in crates %}
-        {% set crate_name = crate.name %}
-        {{ crate_name }}::{{ "ScriptingPlugin" | prefix(val=crate_name) | convert_case(case="upper_camel")}}.build(app);
-        {% endfor %}
-    }
-}
 {% endfilter %}

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

@@ -5,6 +5,7 @@ use std::{collections::HashMap, sync::Arc};
 use bevy::{
     app::Plugin,
     ecs::{entity::Entity, reflect::AppTypeRegistry, world::World},
+    reflect::TypeRegistration,
 };
 use bevy_mod_scripting_derive::script_globals;
 
@@ -20,14 +21,37 @@ use crate::{
 
 use super::AppScriptGlobalsRegistry;
 
-/// A plugin introducing core globals for the BMS framework
-pub struct CoreScriptGlobalsPlugin;
+/// A plugin introducing core globals for the BMS framework.
+///
+/// By default all types added to the type registry are present as globals, you can customize this behavior
+/// by providing a filter function
+pub struct CoreScriptGlobalsPlugin {
+    /// the filter function used to determine which types are registered as globals
+    /// When `true` for the given type registration, the type will be registered as a global.
+    _filter: fn(&TypeRegistration) -> bool,
+
+    /// Whether to register static references to types
+    /// By default static type references such as `Vec3` or `Mat3` are accessible directly from the global namespace.
+    register_static_references: bool,
+}
+
+impl Default for CoreScriptGlobalsPlugin {
+    fn default() -> Self {
+        Self {
+            _filter: |_| true,
+            register_static_references: true,
+        }
+    }
+}
 
 impl Plugin for CoreScriptGlobalsPlugin {
     fn build(&self, _app: &mut bevy::app::App) {}
     fn finish(&self, app: &mut bevy::app::App) {
         profiling::function_scope!("app finish");
-        register_static_core_globals(app.world_mut());
+
+        if self.register_static_references {
+            register_static_core_globals(app.world_mut());
+        }
         register_core_globals(app.world_mut());
     }
 }

crates/bevy_mod_scripting_core/src/lib.rs

@@ -9,11 +9,8 @@ use asset::{
 };
 use bevy::prelude::*;
 use bindings::{
-    function::script_function::AppScriptFunctionRegistry,
-    garbage_collector,
-    globals::{core::CoreScriptGlobalsPlugin, AppScriptGlobalsRegistry},
-    schedule::AppScheduleRegistry,
-    script_value::ScriptValue,
+    function::script_function::AppScriptFunctionRegistry, garbage_collector,
+    globals::AppScriptGlobalsRegistry, schedule::AppScheduleRegistry, script_value::ScriptValue,
     AppReflectAllocator, DynamicScriptComponentPlugin, ReflectAllocator, ReflectReference,
     ScriptTypeRegistration,
 };
@@ -137,9 +134,6 @@ impl<P: IntoScriptPluginParams> Plugin for ScriptingPlugin<P> {
 
         register_script_plugin_systems::<P>(app);
 
-        // add extension for the language to the asset loader
-        once_per_app_init(app);
-
         if !self.additional_supported_extensions.is_empty() {
             app.add_supported_script_extensions(
                 self.additional_supported_extensions,
@@ -149,10 +143,6 @@ impl<P: IntoScriptPluginParams> Plugin for ScriptingPlugin<P> {
 
         register_types(app);
     }
-
-    fn finish(&self, app: &mut App) {
-        once_per_app_finalize(app);
-    }
 }
 
 impl<P: IntoScriptPluginParams> ScriptingPlugin<P> {
@@ -246,36 +236,6 @@ impl<P: IntoScriptPluginParams + AsMut<ScriptingPlugin<P>>> ConfigureScriptPlugi
     }
 }
 
-fn once_per_app_finalize(app: &mut App) {
-    #[derive(Resource)]
-    struct BMSFinalized;
-
-    if app.world().contains_resource::<BMSFinalized>() {
-        return;
-    }
-    app.insert_resource(BMSFinalized);
-
-    // read extensions from asset settings
-    let asset_settings_extensions = app
-        .world_mut()
-        .get_resource_or_init::<ScriptAssetSettings>()
-        .supported_extensions;
-
-    // convert extensions to static array
-    bevy::log::info!(
-        "Initializing BMS with Supported extensions: {:?}",
-        asset_settings_extensions
-    );
-
-    app.register_asset_loader(ScriptAssetLoader {
-        extensions: asset_settings_extensions,
-        preprocessor: None,
-    });
-
-    // pre-register component id's
-    pre_register_componnents(app);
-}
-
 /// Ensures all types with `ReflectComponent` type data are pre-registered with component ID's
 fn pre_register_componnents(app: &mut App) {
     let type_registry = app
@@ -290,34 +250,54 @@ fn pre_register_componnents(app: &mut App) {
     }
 }
 
-// One of registration of things that need to be done only once per app
-fn once_per_app_init(app: &mut App) {
-    #[derive(Resource)]
-    struct BMSInitialized;
-
-    if app.world().contains_resource::<BMSInitialized>() {
-        return;
+/// A plugin defining shared settings between various scripting plugins
+/// It is necessary to register this plugin for any of them to work
+pub struct BMSScriptingInfrastructurePlugin;
+
+impl Plugin for BMSScriptingInfrastructurePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_event::<ScriptErrorEvent>()
+            .add_event::<ScriptCallbackEvent>()
+            .add_event::<ScriptCallbackResponseEvent>()
+            .init_resource::<AppReflectAllocator>()
+            .init_resource::<StaticScripts>()
+            .init_asset::<ScriptAsset>()
+            .init_resource::<AppScriptFunctionRegistry>()
+            .init_resource::<AppScriptGlobalsRegistry>()
+            .insert_resource(AppScheduleRegistry::new());
+
+        app.add_systems(
+            PostUpdate,
+            ((garbage_collector).in_set(ScriptingSystemSet::GarbageCollection),),
+        );
+
+        configure_asset_systems(app);
+
+        DynamicScriptComponentPlugin.build(app);
     }
-    app.insert_resource(BMSInitialized);
-
-    app.add_event::<ScriptErrorEvent>()
-        .add_event::<ScriptCallbackEvent>()
-        .add_event::<ScriptCallbackResponseEvent>()
-        .init_resource::<AppReflectAllocator>()
-        .init_resource::<StaticScripts>()
-        .init_asset::<ScriptAsset>()
-        .init_resource::<AppScriptFunctionRegistry>()
-        .init_resource::<AppScriptGlobalsRegistry>()
-        .insert_resource(AppScheduleRegistry::new());
 
-    app.add_systems(
-        PostUpdate,
-        ((garbage_collector).in_set(ScriptingSystemSet::GarbageCollection),),
-    );
-
-    app.add_plugins((CoreScriptGlobalsPlugin, DynamicScriptComponentPlugin));
-
-    configure_asset_systems(app);
+    fn finish(&self, app: &mut App) {
+        // read extensions from asset settings
+        let asset_settings_extensions = app
+            .world_mut()
+            .get_resource_or_init::<ScriptAssetSettings>()
+            .supported_extensions;
+
+        // convert extensions to static array
+        bevy::log::info!(
+            "Initializing BMS with Supported extensions: {:?}",
+            asset_settings_extensions
+        );
+
+        app.register_asset_loader(ScriptAssetLoader {
+            extensions: asset_settings_extensions,
+            preprocessor: None,
+        });
+
+        // pre-register component id's
+        pre_register_componnents(app);
+        DynamicScriptComponentPlugin.finish(app);
+    }
 }
 
 /// Systems registered per-language
@@ -450,7 +430,7 @@ mod test {
             .resource_mut::<ScriptAssetSettings>()
             .supported_extensions = &["lua", "rhai"];
 
-        once_per_app_finalize(&mut app);
+        BMSScriptingInfrastructurePlugin.finish(&mut app);
 
         let asset_loader = app
             .world()
@@ -482,7 +462,7 @@ mod test {
 
         assert!(app.world_mut().component_id::<Comp>().is_none());
 
-        once_per_app_finalize(&mut app);
+        BMSScriptingInfrastructurePlugin.finish(&mut app);
 
         assert!(app.world_mut().component_id::<Comp>().is_some());
     }

crates/bevy_mod_scripting_functions/Cargo.toml

@@ -12,24 +12,23 @@ categories = ["game-development"]
 readme = "readme.md"
 
 [features]
+bevy_core = ["bevy_bindings"]
+bevy_ecs = ["bevy_bindings"]
+bevy_hierarchy = ["bevy_bindings"]
+bevy_input = ["bevy_bindings"]
+bevy_math = ["bevy_bindings"]
+bevy_reflect = ["bevy_bindings"]
+bevy_time = ["bevy_bindings"]
+bevy_transform = ["bevy_bindings"]
+
 core_functions = []
 bevy_bindings = []
 lua_bindings = ["bevy_mod_scripting_lua"]
 rhai_bindings = ["bevy_mod_scripting_rhai"]
 
 
 [dependencies]
-bevy = { workspace = true, features = [
-    "bevy_asset",
-    "bevy_animation",
-    "bevy_core_pipeline",
-    "bevy_ui",
-    "bevy_pbr",
-    "bevy_render",
-    "bevy_text",
-    "bevy_sprite",
-    "multi_threaded",
-] }
+bevy = { workspace = true }
 profiling = { workspace = true }
 uuid = "1.11"
 smol_str = "0.2.2"

crates/bevy_mod_scripting_functions/src/bevy_bindings/mod.rs

@@ -2,24 +2,19 @@
 #![allow(clippy::all)]
 #![allow(unused, deprecated, dead_code)]
 #![cfg_attr(rustfmt, rustfmt_skip)]
+#[cfg(feature = "bevy_core")]
 pub mod bevy_core;
+#[cfg(feature = "bevy_ecs")]
 pub mod bevy_ecs;
+#[cfg(feature = "bevy_hierarchy")]
 pub mod bevy_hierarchy;
+#[cfg(feature = "bevy_input")]
 pub mod bevy_input;
+#[cfg(feature = "bevy_math")]
 pub mod bevy_math;
+#[cfg(feature = "bevy_reflect")]
 pub mod bevy_reflect;
+#[cfg(feature = "bevy_time")]
 pub mod bevy_time;
+#[cfg(feature = "bevy_transform")]
 pub mod bevy_transform;
-pub struct LuaBevyScriptingPlugin;
-impl ::bevy::app::Plugin for LuaBevyScriptingPlugin {
-    fn build(&self, app: &mut ::bevy::prelude::App) {
-        bevy_core::BevyCoreScriptingPlugin.build(app);
-        bevy_ecs::BevyEcsScriptingPlugin.build(app);
-        bevy_hierarchy::BevyHierarchyScriptingPlugin.build(app);
-        bevy_input::BevyInputScriptingPlugin.build(app);
-        bevy_math::BevyMathScriptingPlugin.build(app);
-        bevy_reflect::BevyReflectScriptingPlugin.build(app);
-        bevy_time::BevyTimeScriptingPlugin.build(app);
-        bevy_transform::BevyTransformScriptingPlugin.build(app);
-    }
-}

crates/bevy_mod_scripting_functions/src/core.rs

@@ -30,9 +30,27 @@ use bindings::{
 use error::InteropError;
 use reflection_extensions::{PartialReflectExt, TypeIdExtensions};
 
+#[allow(unused_variables, reason = "feature flags")]
 pub fn register_bevy_bindings(app: &mut App) {
     #[cfg(feature = "bevy_bindings")]
-    app.add_plugins(crate::bevy_bindings::LuaBevyScriptingPlugin);
+    {
+        #[cfg(feature = "bevy_core")]
+        app.add_plugins(crate::bevy_bindings::bevy_core::BevyCoreScriptingPlugin);
+        #[cfg(feature = "bevy_ecs")]
+        app.add_plugins(crate::bevy_bindings::bevy_ecs::BevyEcsScriptingPlugin);
+        #[cfg(feature = "bevy_hierarchy")]
+        app.add_plugins(crate::bevy_bindings::bevy_hierarchy::BevyHierarchyScriptingPlugin);
+        #[cfg(feature = "bevy_input")]
+        app.add_plugins(crate::bevy_bindings::bevy_input::BevyInputScriptingPlugin);
+        #[cfg(feature = "bevy_math")]
+        app.add_plugins(crate::bevy_bindings::bevy_math::BevyMathScriptingPlugin);
+        #[cfg(feature = "bevy_reflect")]
+        app.add_plugins(crate::bevy_bindings::bevy_reflect::BevyReflectScriptingPlugin);
+        #[cfg(feature = "bevy_time")]
+        app.add_plugins(crate::bevy_bindings::bevy_time::BevyTimeScriptingPlugin);
+        #[cfg(feature = "bevy_transform")]
+        app.add_plugins(crate::bevy_bindings::bevy_transform::BevyTransformScriptingPlugin);
+    }
 }
 
 #[script_bindings(

crates/bevy_mod_scripting_functions/src/lib.rs

@@ -7,6 +7,7 @@ pub mod core;
 pub use core::*;
 
 /// A plugin that registers the core scripting functions.
+#[derive(Default)]
 pub struct ScriptFunctionsPlugin;
 
 impl Plugin for ScriptFunctionsPlugin {