Struct ScriptingPlugin

pub struct ScriptingPlugin<P: IntoScriptPluginParams> {
    pub runtime_settings: RuntimeSettings<P>,
    pub callback_handler: HandlerFn<P>,
    pub context_builder: ContextBuilder<P>,
    pub context_assigner: ContextAssigner<P>,
    pub language_mapper: AssetPathToLanguageMapper,
    pub context_initializers: Vec<ContextInitializer<P>>,
    pub context_pre_handling_initializers: Vec<ContextPreHandlingInitializer<P>>,
    pub supported_extensions: &'static [&'static str],
}

Bevy plugin enabling scripting within the bevy mod scripting framework

Fields

runtime_settings: RuntimeSettings<P>

Settings for the runtime

callback_handler: HandlerFn<P>

The handler used for executing callbacks in scripts

context_builder: ContextBuilder<P>

The context builder for loading contexts

context_assigner: ContextAssigner<P>

The context assigner for assigning contexts to scripts.

language_mapper: AssetPathToLanguageMapper

The asset path to language mapper for the plugin

context_initializers: Vec<ContextInitializer<P>>

initializers for the contexts, run when loading the script

context_pre_handling_initializers: Vec<ContextPreHandlingInitializer<P>>

initializers for the contexts run every time before handling events

supported_extensions: &'static [&'static str]

Supported extensions to be added to the asset settings without the dot

Implementations

impl<P: IntoScriptPluginParams> ScriptingPlugin<P>

pub fn add_context_initializer( &mut self, initializer: ContextInitializer<P>, ) -> &mut Self

Adds a context initializer to the plugin

Initializers will be run every time a context is loaded or re-loaded and before any events are handled

pub fn add_context_pre_handling_initializer( &mut self, initializer: ContextPreHandlingInitializer<P>, ) -> &mut Self

Adds a context pre-handling initializer to the plugin.

Initializers will be run every time before handling events and after the context is loaded or re-loaded.

pub fn add_runtime_initializer( &mut self, initializer: RuntimeInitializer<P>, ) -> &mut Self

Adds a runtime initializer to the plugin.

Initializers will be run after the runtime is created, but before any contexts are loaded.

Trait Implementations

impl<P: IntoScriptPluginParams> Plugin for ScriptingPlugin<P>

fn build(&self, app: &mut App)

Configures the App to which this plugin is added.

fn finish(&self, app: &mut App)

Finish adding this plugin to the App, once all plugins registered are ready. This can be useful for plugins that depends on another plugin asynchronous setup, like the renderer.

fn ready(&self, _app: &App) -> bool

Has the plugin finished its setup? This can be useful for plugins that need something asynchronous to happen before they can finish their setup, like the initialization of a renderer. Once the plugin is ready, finish should be called.

fn cleanup(&self, _app: &mut App)

Runs after all plugins are built and finished, but before the app schedule is executed. This can be useful if you have some resource that other plugins need during their build step, but after build you want to remove it and send it to another thread.

fn name(&self) -> &str

Configures a name for the Plugin which is primarily used for checking plugin uniqueness and debugging.

fn is_unique(&self) -> bool

If the plugin can be meaningfully instantiated several times in an App, override this method to return false.