Struct Executor

pub struct Executor { /* private fields */ }

Executor resource to run scripts.

Implementations

impl Executor

pub fn insert_module(&mut self, module: Module) -> Result<()>

Insert a new module in the rune context Usage:

fn load_module(
    mut executor: ResMut<bevy_scripting_rune::Executor>,
)
{
    let module = rune::Module::with_crate("hello").unwrap();
    // Check rune documentation or our example on how to setup a rune module.
    executor.insert_module(module).unwrap();
}

Examples found in repository

examples/example.rs (line 45)

fn setup(
    asset_server: Res<AssetServer>,
    mut my_resource: ResMut<MyResource>,
    mut executor: ResMut<bevy_scripting_rune::Executor>,
) {
    // Setup the module
    let mut module = rune::Module::with_crate("example").unwrap();
    module.ty::<MyStructure>().unwrap();
    module.function_meta(MyStructure::update_value).unwrap();
    module.function_meta(MyStructure::get_value).unwrap();

    // Insert the module in the executor
    executor.insert_module(module).unwrap();

    // Load script asset
    my_resource.script_handle = asset_server.load("example.rn");
}

pub fn load_script(&mut self, script: &Script) -> Result<u32>

Load a script, either from a loaded asset or inlined.

Usage:

fn run_script(
    mut executor: ResMut<bevy_scripting_rune::Executor>,
)
{
    executor.load_script(&Script::memory("pub fn plus(a, b) { a + b }").unwrap());
    executor.build().unwrap();
    let r = executor.call::<i32>("plus", (38, 4)).unwrap();
}

Examples found in repository

examples/example.rs (line 63)

fn compile_script(
    mut ev_asset: EventReader<AssetEvent<bevy_scripting_rune::Script>>,
    script_assets: Res<Assets<bevy_scripting_rune::Script>>,
    mut executor: ResMut<bevy_scripting_rune::Executor>,
    mut next_state: ResMut<NextState<States>>,
) {
    for ev in ev_asset.read() {
        match ev {
            AssetEvent::LoadedWithDependencies { id } => {
                // Retrieve the script and compile it
                let script = script_assets.get(*id).unwrap();
                executor.load_script(script).unwrap();
                executor.build().unwrap();
                // Move to the running state
                next_state.set(States::Running);
            }
            _ => {}
        }
    }
}

pub fn unload_script(&mut self, script_id: &u32) -> Result<()>

Unload a script that was loaded with load_script, using the id that was returned after the call to load_script.

pub fn build(&mut self) -> Result<()>

Build the virtual machine context. It needs to be called after adding a module or loading a script.

Examples found in repository

examples/example.rs (line 64)

fn compile_script(
    mut ev_asset: EventReader<AssetEvent<bevy_scripting_rune::Script>>,
    script_assets: Res<Assets<bevy_scripting_rune::Script>>,
    mut executor: ResMut<bevy_scripting_rune::Executor>,
    mut next_state: ResMut<NextState<States>>,
) {
    for ev in ev_asset.read() {
        match ev {
            AssetEvent::LoadedWithDependencies { id } => {
                // Retrieve the script and compile it
                let script = script_assets.get(*id).unwrap();
                executor.load_script(script).unwrap();
                executor.build().unwrap();
                // Move to the running state
                next_state.set(States::Running);
            }
            _ => {}
        }
    }
}

pub fn call<T>(&self, name: impl AsRef<str>, args: impl Args) -> Result<T>

where T: FromValue,

Call a rune function.

Usage:

fn run_script(
    mut executor: ResMut<bevy_scripting_rune::Executor>,
)
{
    let r = executor.call::<i32>("plus", (38, 4)).unwrap();
}

Examples found in repository

examples/example.rs (lines 76-84)

fn run(my_resource: ResMut<MyResource>, executor: Res<bevy_scripting_rune::Executor>) {
    // Call the update_value function from the script
    executor
        .call::<()>(
            "update_value",
            (
                MyStructure {
                    value: my_resource.value.clone(),
                },
                4.0,
            ),
        )
        .unwrap();
    // Display the result
    println!("my_structure.value = {}", my_resource.value.lock().unwrap());
}

Trait Implementations

impl Default for Executor

fn default() -> Self

Returns the “default value” for a type.

impl Resource for Executor

where Self: Send + Sync + 'static,