Struct PluginContext 

pub struct PluginContext<'a, 'b> {

    pub scenes: &'a mut SceneContainer,
    pub resource_manager: &'a ResourceManager,
    pub user_interfaces: &'a mut UiContainer,
    pub graphics_context: &'a mut GraphicsContext,
    pub dt: f32,
    pub lag: &'b mut f32,
    pub serialization_context: &'a Arc<SerializationContext>,
    pub widget_constructors: &'a Arc<WidgetConstructorContainer>,
    pub dyn_type_constructors: &'a Arc<DynTypeConstructorContainer>,
    pub performance_statistics: &'a PerformanceStatistics,
    pub elapsed_time: f32,
    pub script_processor: &'a ScriptProcessor,
    pub async_scene_loader: &'a mut AsyncSceneLoader,
    pub loop_controller: ApplicationLoopController<'b>,
    pub task_pool: &'a mut TaskPoolHandler,
    pub input_state: &'a InputState,
}

Contains plugin environment.

Fields

scenes: &'a mut SceneContainer

A reference to scene container of the engine. You can add new scenes from Plugin methods by using SceneContainer::add.

resource_manager: &'a ResourceManager

A reference to the resource manager, it can be used to load various resources and manage them. See ResourceManager 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.

graphics_context: &'a mut GraphicsContext

A reference to the graphics_context, it contains a reference to the window and the current renderer. It could be GraphicsContext::Uninitialized if your application is suspended (possible only on Android; it is safe to call GraphicsContext::as_initialized_ref or GraphicsContext::as_initialized_mut on every other platform).

dt: f32

The time (in seconds) that passed since last call of a method in which the context was passed. It has fixed value that is defined by a caller (in most cases it is Executor).

lag: &'b mut f32

A reference to time accumulator, that holds remaining amount of time that should be used to update a plugin. A caller splits lag into multiple sub-steps using dt and thus stabilizes update rate. The main use of this variable, is to be able to reset lag when you doing some heavy calculations in a your game loop (i.e. loading a new level) so the engine won’t try to “catch up” with all the time that was spent in heavy calculation.

serialization_context: &'a Arc<SerializationContext>

A reference to serialization context of the engine. See SerializationContext for more info.

widget_constructors: &'a Arc<WidgetConstructorContainer>

A reference to serialization context of the engine. See WidgetConstructorContainer for more info.

dyn_type_constructors: &'a Arc<DynTypeConstructorContainer>

A container with constructors for dynamic types. See DynTypeConstructorContainer for more info.

performance_statistics: &'a PerformanceStatistics

Performance statistics from the last frame.

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.

script_processor: &'a ScriptProcessor

Script processor is used to run script methods in a strict order.

async_scene_loader: &'a mut AsyncSceneLoader

Asynchronous scene loader. It is used to request scene loading. See AsyncSceneLoader docs for usage example.

loop_controller: ApplicationLoopController<'b>

Special field that associates the main application event loop (not game loop) with OS-specific windows. It also can be used to alternate control flow of the application. None if the engine is running in headless mode.

task_pool: &'a mut TaskPoolHandler

Task pool for asynchronous task management.

input_state: &'a InputState

A stored state of most common input events. It is used a “shortcut” in cases where event-based approach is too verbose. It may be useful in simple scenarios where you just need to know if a button (on keyboard, mouse) was pressed and do something.

Important: this structure does not track from which device the corresponding event has come from, if you have more than one keyboard and/or mouse, use event-based approach instead!

Implementations

impl<'a, 'b> PluginContext<'a, 'b>

pub fn load_ui<U, P, C>(&mut self, path: U, callback: C)

where U: AsRef<Path> + Send + 'static, P: Plugin, for<'c, 'd> C: Fn(Result<UserInterface, VisitError>, &mut P, &mut PluginContext<'c, 'd>) -> GameResult + 'static,

Spawns an asynchronous task that tries to load a user interface from the given path. When the task is completed, the specified callback is called that can be used to modify the UI. The loaded UI must be registered in the engine, otherwise it will be discarded.

Example

#[derive(Default, Visit, Reflect, Debug)]
#[reflect(non_cloneable)]
struct MyGame {}

impl Plugin for MyGame {
    fn init(&mut self, _scene_path: Option<&str>, mut ctx: PluginContext) -> GameResult {
        ctx.load_ui("data/my.ui", |result, game: &mut MyGame, mut ctx| {
            // The loaded UI must be registered in the engine.
            *ctx.user_interfaces.first_mut() = result?;
            Ok(())
        });
        Ok(())
    }
}