Struct ScriptContext

pub struct ScriptContext<'a, 'b, 'c> {

    pub dt: f32,
    pub elapsed_time: f32,
    pub plugins: PluginsRefMut<'a>,
    pub handle: Handle<Node>,
    pub scene: &'b mut Scene,
    pub scene_handle: Handle<Scene>,
    pub resource_manager: &'a ResourceManager,
    pub message_sender: &'c ScriptMessageSender,
    pub message_dispatcher: &'c mut ScriptMessageDispatcher,
    pub task_pool: &'a mut TaskPoolHandler,
    pub graphics_context: &'a mut GraphicsContext,
    pub user_interfaces: &'a mut UiContainer,
    pub script_index: usize,
}

A set of data, that provides contextual information for script methods.

Fields

dt: f32

Amount of time that passed from last call. It has valid values only when called from on_update.

elapsed_time: f32

Amount of time (in seconds) that passed from creation of the engine. Keep in mind, that this value is not guaranteed to match real time. A user can change delta time with which the engine “ticks” and this delta time affects elapsed time.

plugins: PluginsRefMut<'a>

A slice of references to all registered plugins. For example you can store some “global” data in a plugin and access it later in scripts. A simplest example would be something like this:

#[derive(Visit, Reflect, Default, Debug)]
struct Game {
    player_name: String,
}

impl Plugin for Game {}

#[derive(Visit, Reflect, Clone, Default, Debug, TypeUuidProvider, ComponentProvider)]
#[type_uuid(id = "f732654e-5e3c-4b52-9a3d-44c0cfb14e18")]
struct MyScript {}

impl ScriptTrait for MyScript {
    fn on_update(&mut self, ctx: &mut ScriptContext) {
        let game = ctx.plugins.get::<Game>();

        println!("Player name is: {}", game.player_name);
    }
}

Since player name usually a sort of a “global” variable, it can be stored in the plugin itself, and to access the plugin all you need to do is to call ctx.plugins.get::<Game>(). You can also mutate any data in a plugin by getting the mutable reference via get_mut() method.

handle: Handle<Node>

Handle of a node to which the script instance belongs to. To access the node itself use scene field:

let node_mut = &mut context.scene.graph[context.handle];

scene: &'b mut Scene

A reference to a scene the script instance belongs to. You have full mutable access to scene content in most of the script methods.

scene_handle: Handle<Scene>

A handle of a scene the script instance belongs to.

resource_manager: &'a ResourceManager

A reference to resource manager, use it to load resources.

message_sender: &'c ScriptMessageSender

An message sender. Every message sent via this sender will be then passed to every ScriptTrait::on_message method of every script.

message_dispatcher: &'c mut ScriptMessageDispatcher

A message dispatcher. If you need to receive messages of a particular type, you must subscribe to a type explicitly. See ScriptTrait::on_message for more examples.

task_pool: &'a mut TaskPoolHandler

Task pool for asynchronous task management.

graphics_context: &'a mut GraphicsContext

Current graphics context of the engine. See GraphicsContext docs for more info.

user_interfaces: &'a mut UiContainer

A reference to user interface container of the engine. The engine guarantees that there’s at least one user interface exists. Use context.user_interfaces.first()/first_mut() to get a reference to it.

script_index: usize

Index of the script. Never save this index, it is only valid while this context exists!